0xray 3.4.1 → 3.4.3

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

@@ -0,0 +1,90 @@
+/**
+ * Core types for the 0xRay Governance System.
+ * These types are used by the GovernanceService, Governance MCP,
+ * and all integrations.
+ */
+export type ProposalType = 'fix' | 'refactor' | 'guard' | 'automate' | 'codify' | 'strategic' | 'compliance' | 'metamorphosis';
+export interface GovernanceProposal {
+    id: string;
+    type: ProposalType;
+    title: string;
+    description: string;
+    evidence?: string[];
+    source?: 'inference' | 'reflection' | 'manual' | 'ci' | 'phase-planning' | 'metamorphosis';
+    confidence?: number;
+    metadata?: Record<string, unknown>;
+    tags?: string[];
+}
+export interface GovernanceVote {
+    server: string;
+    decision: 'approve' | 'reject' | 'abstain' | 'needs_revision';
+    confidence: number;
+    reasoning: string;
+    weight?: number;
+    moralTension?: 'Aligned' | 'Mild' | 'Significant' | 'Critical' | undefined;
+    moralScore?: number | undefined;
+    moralFusion?: number | undefined;
+    detectedVirtues?: string[] | undefined;
+    detectedConcerns?: string[] | undefined;
+}
+export interface GovernanceResult {
+    proposalId: string;
+    finalDecision: 'approve' | 'reject' | 'needs_revision' | 'abstain';
+    averageConfidence: number;
+    votes: GovernanceVote[];
+    reasoningSummary: string;
+    recommendedActions?: string[];
+    externalContext?: Record<string, unknown>;
+    moralOverride?: 'rejected_critical' | 'downgraded_significant' | 'none';
+    metamorphosisScore?: number;
+}
+export interface GovernanceContext {
+    project?: string;
+    phase?: string;
+    source?: string;
+    reflectionId?: string;
+    inferenceCycleId?: string;
+    tags?: string[];
+}
+export interface GovernOptions {
+    requireExternalDynamo?: boolean;
+    minConfidence?: number;
+    enableSolarAdjustment?: boolean;
+    timeoutMs?: number;
+    maxAbstentionThreshold?: number;
+    metamorphosisThreshold?: number;
+}
+export interface GovernanceRequest {
+    proposals: GovernanceProposal[];
+    context?: GovernanceContext;
+    options?: GovernOptions;
+}
+export interface GovernanceResponse {
+    results: GovernanceResult[];
+    overallDecision: 'approve' | 'needs_revision' | 'reject';
+    summary: {
+        total: number;
+        approved: number;
+        needsRevision: number;
+        rejected: number;
+    };
+}
+export interface ActiveCodexSnapshot {
+    source: string | null;
+    loaded_at: string;
+    term_count: number;
+    version: string;
+    last_updated?: string;
+    governance_ssot: boolean;
+    is_fallback: boolean;
+    note: string;
+    dynamo_required: boolean;
+    codex?: Record<string, unknown>;
+}
+export interface ICodexPolicyProvider {
+    getCurrentCodex(includeRaw?: boolean): Promise<ActiveCodexSnapshot>;
+    getTermCount(): Promise<number>;
+}
+export declare function normalizeProposalWithSource(proposal: GovernanceProposal): GovernanceProposal & {
+    source: string;
+};

package/dist/governance/llm-governance-provider.d.ts

@@ -0,0 +1,13 @@
+export type GovernanceRole = "code-review" | "security-audit" | "researcher";
+export interface GovernanceVote {
+    decision: "approve" | "reject" | "abstain";
+    confidence: number;
+    reasoning: string;
+}
+export declare function tryLLMGovernance(role: GovernanceRole, proposalTitle: string, proposalDescription: string, evidence: string[], proposalType: string): Promise<GovernanceVote | null>;
+export declare function checkHermesOAuthStatus(): {
+    configured: boolean;
+    endpoint?: string;
+    model?: string;
+    error?: string;
+};

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 0xRay Framework - Main Entry Point
+ *
+ * This is the main entry point for the 0xRay framework.
+ * It exports the core initialization function and key components.
+ */
+export { XrayOrchestrator } from "./orchestrator/orchestrator.js";
+export { XrayStateManager } from "./state/index.js";
+export { AgentDelegator } from "./delegation/index.js";
+export { frameworkLogger } from "./core/framework-logger.js";
+export { BUILTIN_CODEX } from "./core/codex-formatter.js";
+import { defaultXrayConfig } from "./core/index.js";
+export { defaultXrayConfig };
+export { OpenClawIntegration, initializeOpenClawIntegration, getOpenClawIntegration, shutdownOpenClawIntegration } from "./integrations/openclaw/index.js";
+export type { OpenClawIntegrationConfig } from "./integrations/openclaw/types.js";
+export declare function initializeXray(config?: {}): {
+    success: boolean;
+    config: {
+        enableOrchestrator: boolean;
+        enableBootOrchestrator: boolean;
+        enableStateManagement: boolean;
+        enableHooks: boolean;
+        enableCodexInjection: boolean;
+        enableProcessors: boolean;
+        enablePostProcessor: boolean;
+    };
+    message: string;
+};

package/dist/inference/deploy-verifier.d.ts

@@ -0,0 +1,26 @@
+export interface DeployVerificationResult {
+    success: boolean;
+    packageVersion: string;
+    tarballPath: string;
+    installDir: string;
+    checks: DeployCheck[];
+    duration: number;
+    timestamp: string;
+}
+export interface DeployCheck {
+    name: string;
+    passed: boolean;
+    output: string;
+    duration: number;
+}
+export declare class DeployVerifier {
+    private projectRoot;
+    constructor(projectRoot?: string);
+    verify(): DeployVerificationResult;
+    quickVerify(): DeployVerificationResult;
+    private runCheck;
+    private exec;
+    private readPackageJson;
+    private cleanup;
+    private result;
+}

package/dist/inference/index.d.ts

@@ -0,0 +1,10 @@
+export { analyzeStructuralPatterns } from "./semantic-patterns.js";
+export type { StructuralPattern } from "./semantic-patterns.js";
+export { captureSessionInference, saveSessionInference, } from "./session-capture.js";
+export type { SessionInference, ReasoningLink, SessionMetrics, } from "./session-capture.js";
+export { shouldTriggerCycle, accumulateCorpus } from "./inference-accumulator.js";
+export type { InferenceCorpus, RecurringPattern, RecurringProblem } from "./inference-accumulator.js";
+export { InferenceCycle } from "./inference-cycle.js";
+export type { InferenceProposal, InferenceCycleResult, CyclePhase } from "./inference-cycle.js";
+export { DeployVerifier } from "./deploy-verifier.js";
+export type { DeployVerificationResult, DeployCheck } from "./deploy-verifier.js";

package/dist/inference/inference-accumulator.d.ts

@@ -0,0 +1,29 @@
+import { SessionInference } from "./session-capture.js";
+export interface InferenceCorpus {
+    sessions: SessionInference[];
+    totalCommits: number;
+    recurringPatterns: RecurringPattern[];
+    recurringProblems: RecurringProblem[];
+    uniqueApproaches: string[];
+    allWrongTurns: string[];
+    collectedAt: string;
+}
+export interface RecurringPattern {
+    name: string;
+    occurrences: number;
+    avgConfidence: number;
+    sessions: string[];
+    evidence: string[];
+    description: string;
+}
+export interface RecurringProblem {
+    pattern: string;
+    occurrences: number;
+    sessions: string[];
+}
+export declare function shouldTriggerCycle(inferenceDir: string, lastCycleFile: string): {
+    trigger: boolean;
+    reason: string;
+};
+export declare function accumulateCorpus(inferenceDir: string): InferenceCorpus;
+export declare function loadSessionInferences(dir: string): SessionInference[];

package/dist/inference/inference-agent-invoker.d.ts

@@ -0,0 +1,3 @@
+import type { AgentInvoker } from "./inference-cycle.js";
+export declare function invokeAgent(agentName: string, prompt: string, projectRoot: string, agentInvoker?: AgentInvoker | null): Promise<string>;
+export declare function invokeViaOpencode(agentName: string, prompt: string, projectRoot: string): Promise<string>;

package/dist/inference/inference-applier.d.ts

@@ -0,0 +1,4 @@
+import type { InferenceProposal, AgentInvoker } from "./inference-cycle.js";
+export declare function applyProposals(proposals: InferenceProposal[], projectRoot: string, agentInvoker: AgentInvoker | null, options: {
+    skipResearcherReview?: boolean;
+}): Promise<void>;

package/dist/inference/inference-cycle.d.ts

@@ -0,0 +1,70 @@
+import { DeployVerificationResult } from "./deploy-verifier.js";
+export interface InferenceProposal {
+    id: string;
+    type: "fix" | "refactor" | "automate" | "guard" | "codify";
+    title: string;
+    description: string;
+    evidence: string[];
+    confidence: number;
+    source: "recurring_problem" | "recurring_pattern" | "wrong_turn";
+    status: "pending" | "approved" | "rejected" | "applied" | "failed";
+}
+export interface InferenceCycleResult {
+    cycleId: string;
+    triggered: boolean;
+    triggerReason: string;
+    corpusSummary: {
+        sessions: number;
+        totalCommits: number;
+        recurringPatterns: number;
+        recurringProblems: number;
+    };
+    proposals: InferenceProposal[];
+    votes: {
+        proposalId: string;
+        decision: string;
+        confidence: number;
+        details: string[];
+    }[];
+    deployVerification?: DeployVerificationResult | undefined;
+    phase: CyclePhase;
+    completedAt: string;
+    duration: number;
+}
+export type CyclePhase = "idle" | "collecting" | "proposing" | "governing" | "applying" | "deploying" | "verifying" | "complete" | "failed";
+export type AgentInvoker = (agentName: string, prompt: string) => Promise<string>;
+export interface InferenceCycleOptions {
+    skipDeployVerify?: boolean;
+    skipApply?: boolean;
+    skipResearcherReview?: boolean;
+    force?: boolean;
+}
+export declare class InferenceCycle {
+    private static instances;
+    private static reEntryLock;
+    private static governedProposalIds;
+    static getInstance(projectRoot?: string, options?: InferenceCycleOptions): InferenceCycle;
+    static resetInstance(): void;
+    private inferenceDir;
+    private stateDir;
+    private projectRoot;
+    private phase;
+    private opencodeAvailable;
+    private agentInvoker;
+    private options;
+    constructor(projectRoot?: string, agentInvoker?: AgentInvoker, options?: InferenceCycleOptions);
+    governExternalProposals(proposals: InferenceProposal[]): Promise<InferenceCycleResult>;
+    maybeRunCycle(): Promise<InferenceCycleResult>;
+    private governProposals;
+    private isGovernanceMcpPreferred;
+    private parseGovernanceMcpResponse;
+    private extractTextFromNdjson;
+    private resolveOpencodeRoot;
+    private setPhase;
+    getPhase(): CyclePhase;
+    private saveCycleState;
+    private appendHistory;
+    private loadHistory;
+    private buildBlockedResult;
+    private buildResult;
+}

package/dist/inference/inference-proposal-generator.d.ts

@@ -0,0 +1,3 @@
+import type { InferenceProposal, InferenceCycleResult } from "./inference-cycle.js";
+import type { InferenceCorpus } from "./inference-accumulator.js";
+export declare function generateProposals(corpus: InferenceCorpus, history?: InferenceCycleResult[]): InferenceProposal[];

package/dist/inference/semantic-patterns.d.ts

@@ -0,0 +1,7 @@
+export interface StructuralPattern {
+    name: string;
+    confidence: number;
+    evidence: string[];
+    description: string;
+}
+export declare function analyzeStructuralPatterns(fromRef: string, toRef: string): StructuralPattern[];

package/dist/inference/session-capture.d.ts

@@ -0,0 +1,32 @@
+import { StructuralPattern } from "./semantic-patterns.js";
+export interface SessionInference {
+    sessionId: string;
+    timestamp: string;
+    span: {
+        from: string;
+        to: string;
+    };
+    problems: string[];
+    approaches: string[];
+    wrongTurns: string[];
+    solutions: string[];
+    reasoningChain: ReasoningLink[];
+    patterns: StructuralPattern[];
+    metrics: SessionMetrics;
+}
+export interface ReasoningLink {
+    from: string;
+    to: string;
+    reasoning: string;
+}
+export interface SessionMetrics {
+    commits: number;
+    filesChanged: number;
+    insertions: number;
+    deletions: number;
+    filesAdded: number;
+    filesDeleted: number;
+    uniqueDirs: number;
+}
+export declare function captureSessionInference(fromRef: string, toRef: string): SessionInference | null;
+export declare function saveSessionInference(inference: SessionInference, outputDir?: string): string;

package/dist/infrastructure/iac-validator.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Infrastructure as Code Validation System
+ *
+ * Comprehensive IaC validation with schema enforcement, pre-commit hooks,
+ * and automated CI/CD integration for enterprise-grade cloud deployments.
+ *
+ * @since 2026-01-08
+ */
+import { z } from "zod";
+export declare enum ValidationSeverity {
+    ERROR = "error",
+    WARNING = "warning",
+    INFO = "info"
+}
+export interface ValidationResult {
+    file: string;
+    valid: boolean;
+    errors: ValidationError[];
+    warnings: ValidationWarning[];
+}
+export interface ValidationError {
+    path: string;
+    message: string;
+    severity: ValidationSeverity.ERROR;
+    line?: number;
+    column?: number;
+}
+export interface ValidationWarning {
+    path: string;
+    message: string;
+    severity: ValidationSeverity.WARNING;
+    suggestion?: string;
+}
+export declare const CloudFormationSchema: z.ZodObject<{
+    AWSTemplateFormatVersion: z.ZodOptional<z.ZodString>;
+    Description: z.ZodOptional<z.ZodString>;
+    Metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    Parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        Type: z.ZodString;
+        Default: z.ZodOptional<z.ZodAny>;
+        AllowedValues: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+        Description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    Mappings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>>>;
+    Conditions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    Transform: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    Resources: z.ZodRecord<z.ZodString, z.ZodObject<{
+        Type: z.ZodString;
+        Properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        DependsOn: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        Metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        DeletionPolicy: z.ZodOptional<z.ZodEnum<{
+            Delete: "Delete";
+            Retain: "Retain";
+            Snapshot: "Snapshot";
+        }>>;
+    }, z.core.$strip>>;
+    Outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        Description: z.ZodOptional<z.ZodString>;
+        Value: z.ZodAny;
+        Export: z.ZodOptional<z.ZodObject<{
+            Name: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const TerraformSchema: z.ZodObject<{
+    terraform: z.ZodOptional<z.ZodObject<{
+        required_version: z.ZodOptional<z.ZodString>;
+        required_providers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            version: z.ZodOptional<z.ZodString>;
+            source: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        backend: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$strip>>;
+    provider: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>>;
+    resource: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>>>;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>>>;
+    variable: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+        default: z.ZodOptional<z.ZodAny>;
+        description: z.ZodOptional<z.ZodString>;
+        validation: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            condition: z.ZodAny;
+            error_message: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        value: z.ZodAny;
+        description: z.ZodOptional<z.ZodString>;
+        sensitive: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    locals: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    module: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>>;
+}, z.core.$strip>;
+export declare const KubernetesSchema: z.ZodObject<{
+    apiVersion: z.ZodString;
+    kind: z.ZodString;
+    metadata: z.ZodObject<{
+        name: z.ZodString;
+        namespace: z.ZodOptional<z.ZodString>;
+        labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        annotations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>;
+    spec: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    status: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, z.core.$strip>;
+export declare const DockerComposeSchema: z.ZodObject<{
+    version: z.ZodOptional<z.ZodString>;
+    services: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        image: z.ZodOptional<z.ZodString>;
+        build: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>>;
+        ports: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+        environment: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodString>, z.ZodArray<z.ZodString>]>>;
+        volumes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        depends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        networks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        restart: z.ZodOptional<z.ZodEnum<{
+            always: "always";
+            no: "no";
+            "on-failure": "on-failure";
+            "unless-stopped": "unless-stopped";
+        }>>;
+    }, z.core.$strip>>>;
+    volumes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>>;
+    networks: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>>;
+}, z.core.$strip>;
+export declare class IaCValidator {
+    private schemas;
+    constructor();
+    private registerSchemas;
+    validateFile(filePath: string): Promise<ValidationResult>;
+    private validateJsonFile;
+    private validateYamlFile;
+    private performSecurityChecks;
+    validateDirectory(dirPath: string): Promise<ValidationResult[]>;
+    private findIaCFiles;
+}
+export declare class PreCommitValidator {
+    private validator;
+    constructor();
+    validateStagedFiles(): Promise<{
+        success: boolean;
+        results: ValidationResult[];
+    }>;
+    validateAllIaCFiles(): Promise<{
+        success: boolean;
+        results: ValidationResult[];
+    }>;
+}
+export declare function validateCommand(args: string[]): Promise<void>;