0xray 4.0.12 → 4.0.13

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

@@ -1,167 +0,0 @@
-/**
- * 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/base/types.js

@@ -1,117 +0,0 @@
-/**
- * Integration Base Types
- *
- * Common TypeScript interfaces for 0xRay integrations.
- * Provides a standardized foundation for all integration types.
- *
- * @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/enforcement-gate.d.ts

@@ -1,44 +0,0 @@
-/**
- * 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/enforcement-gate.js

@@ -1,348 +0,0 @@
-/**
- * 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
- */
-import { frameworkLogger } from "../core/framework-logger.js";
-// ── Registry Cache ─────────────────────────────────────────────
-function getGlobalRegistry() {
-    if (globalThis.xrayValidatorRegistry) {
-        return globalThis.xrayValidatorRegistry;
-    }
-    return null;
-}
-async function loadRegistry() {
-    const cached = getGlobalRegistry();
-    if (cached)
-        return cached;
-    const candidatePaths = [
-        () => import("../enforcement/validators/validator-registry.js"),
-        () => import(/* skip-ts */ "../../node_modules/0xray/dist/enforcement/validators/validator-registry.js"),
-    ];
-    for (const load of candidatePaths) {
-        try {
-            const mod = await load();
-            const registry = mod.globalValidatorRegistry;
-            if (registry) {
-                globalThis.xrayValidatorRegistry = registry;
-                return registry;
-            }
-        }
-        catch {
-            continue;
-        }
-    }
-    return null;
-}
-// ── v3 PostProcessor Loader ────────────────────────────────────
-async function loadV3PostProcessor() {
-    const global = globalThis;
-    if (global.xrayPostProcessor && typeof global.xrayPostProcessor.executePostProcessorLoop === "function") {
-        return global.xrayPostProcessor;
-    }
-    // xrayPostProcessor fallback removed in v2.2
-    return null;
-}
-// ── Context Builder ────────────────────────────────────────────
-function buildValidationContext(tool, args) {
-    const op = mapToolToOperation(tool);
-    const files = [];
-    let newCode;
-    if (args) {
-        const filePath = args.filePath || args.path || args.file || "";
-        if (filePath)
-            files.push(filePath);
-        if (typeof args.content === "string") {
-            newCode = args.content;
-        }
-        else if (typeof args.code === "string") {
-            newCode = args.code;
-        }
-        else if (args.content instanceof Map && args.content.size > 0) {
-            newCode = Array.from(args.content.values()).join("\n");
-        }
-        else if (args.newCode instanceof Map && args.newCode.size > 0) {
-            newCode = Array.from(args.newCode.values()).join("\n");
-        }
-    }
-    return { operation: op, files, ...(newCode ? { newCode } : {}) };
-}
-function mapToolToOperation(tool) {
-    const writeTools = /^(write|edit|create|modify|patch|insert|replace|apply_diff|overwrite_file|write_file)$/i;
-    const readTools = /^(read|search|find|list|grep|glob|lookup|get)$/i;
-    const execTools = /^(run|execute|bash|terminal|command|shell)$/i;
-    if (writeTools.test(tool))
-        return "write";
-    if (readTools.test(tool))
-        return "read";
-    if (execTools.test(tool))
-        return "execute";
-    return "modify";
-}
-function isCodeProducingTool(tool) {
-    return mapToolToOperation(tool) === "write" || mapToolToOperation(tool) === "modify";
-}
-// ── beforeToolHook ─────────────────────────────────────────────
-export async function beforeToolHook(tool, args, _context) {
-    const start = Date.now();
-    try {
-        const registry = await loadRegistry();
-        if (!registry) {
-            await frameworkLogger.log("enforcement-gate", "before-hook-registry-unavailable", "warning", { tool });
-            return { allowed: true, blocked: false, violations: [], resonance: 0.85, duration: Date.now() - start };
-        }
-        const validationCtx = buildValidationContext(tool, args);
-        const allValidators = registry.getAllValidators();
-        const violations = [];
-        for (const v of allValidators) {
-            try {
-                const result = await v.validate(validationCtx);
-                if (!result.passed) {
-                    violations.push({
-                        ruleId: v.ruleId || v.id,
-                        severity: v.severity || "warning",
-                        message: result.message || `${v.id} violation detected`,
-                        ...(result.suggestions ? { suggestions: result.suggestions } : { suggestions: [] }),
-                    });
-                }
-            }
-            catch (valErr) {
-                await frameworkLogger.log("enforcement-gate", "validator-error", "warning", {
-                    ruleId: v.id,
-                    error: String(valErr),
-                });
-            }
-        }
-        const blockingViolations = violations.filter((v) => v.severity === "error" || v.severity === "blocking");
-        const blocked = blockingViolations.length > 0;
-        let resonance = 1.0;
-        for (const v of violations) {
-            resonance -= v.severity === "error" || v.severity === "blocking" ? 0.15 : 0.05;
-        }
-        resonance = Math.max(0.1, Math.min(1.0, resonance));
-        if (blocked || violations.length > 0) {
-            await frameworkLogger.log("enforcement-gate", "before-hook-result", blocked ? "error" : "warning", {
-                tool,
-                blocked,
-                violationCount: violations.length,
-                resonance,
-                duration: Date.now() - start,
-                violations: violations.map((v) => `[${v.severity}] ${v.ruleId}: ${v.message}`),
-            });
-        }
-        return {
-            allowed: !blocked,
-            blocked,
-            violations,
-            resonance,
-            duration: Date.now() - start,
-        };
-    }
-    catch (err) {
-        await frameworkLogger.log("enforcement-gate", "before-hook-error", "error", {
-            tool,
-            error: String(err),
-        });
-        return { allowed: true, blocked: false, violations: [], resonance: 0.85, duration: Date.now() - start };
-    }
-}
-// ── afterToolHook ──────────────────────────────────────────────
-export async function afterToolHook(tool, args, _result, _error, _context) {
-    const start = Date.now();
-    try {
-        if (!isCodeProducingTool(tool)) {
-            return { processed: false, violations: [], processorResults: [], governanceTriggered: false, duration: Date.now() - start };
-        }
-        await frameworkLogger.log("enforcement-gate", "after-hook-start", "info", { tool });
-        const registry = await loadRegistry();
-        const violations = [];
-        const processorResults = [];
-        // Step 1: Run per-pipeline validators (same as PostProcessor.ts:382-432)
-        if (registry) {
-            const validationCtx = buildValidationContext(tool, args);
-            const pipelineRules = ["error-resolution", "loop-safety", "boot-wiring", "console-log-usage"];
-            for (const ruleId of pipelineRules) {
-                try {
-                    const v = registry.getValidator(ruleId);
-                    if (!v)
-                        continue;
-                    const result = await v.validate(validationCtx);
-                    if (!result.passed) {
-                        violations.push({
-                            ruleId,
-                            severity: v.severity || "warning",
-                            message: result.message || `${ruleId} violation`,
-                            ...(result.suggestions ? { suggestions: result.suggestions } : { suggestions: [] }),
-                        });
-                    }
-                }
-                catch (valErr) {
-                    await frameworkLogger.log("enforcement-gate", "pipeline-validator-error", "warning", {
-                        ruleId,
-                        error: String(valErr),
-                    });
-                }
-            }
-        }
-        // Step 2: Legacy ProcessorManager compat (test-auto-creation etc.)
-        try {
-            const stateManager = await loadStateManager();
-            const ProcessorManager = await loadProcessorManager();
-            if (ProcessorManager && stateManager) {
-                const pm = new ProcessorManager(stateManager);
-                const config = { preProcessors: ["preValidate", "codexCompliance", "versionCompliance"] };
-                const registered = await pm.registerAllProcessors(config);
-                processorResults.push({ name: "register-processors", success: true });
-                if (registered) {
-                    const preCtx = {
-                        operation: mapToolToOperation(tool),
-                        files: args?.filePath ? [args.filePath] : [],
-                        directory: process.cwd(),
-                    };
-                    await pm.executePreProcessors(preCtx);
-                    processorResults.push({ name: "pre-processors", success: true });
-                }
-            }
-        }
-        catch (pmErr) {
-            processorResults.push({ name: "processor-manager", success: false, error: String(pmErr) });
-            await frameworkLogger.log("enforcement-gate", "processor-error", "warning", {
-                tool,
-                error: String(pmErr),
-            });
-        }
-        // Step 3: Try v3 PostProcessor loop (with critical violations from pipeline validators)
-        try {
-            const v3pp = await loadV3PostProcessor();
-            if (v3pp) {
-                const critical = violations.filter(v => v.severity === "error" || v.severity === "blocking");
-                const postCtx = {
-                    trigger: "manual",
-                    operation: mapToolToOperation(tool),
-                    filePath: args?.filePath || args?.path || "",
-                    directory: process.cwd(),
-                    newCode: buildValidationContext(tool, args).newCode || "",
-                    files: buildValidationContext(tool, args).files || [],
-                    tool,
-                    metadata: { source: "enforcement-gate", hookType: "integration" },
-                    criticalViolations: critical.length > 0 ? critical : undefined,
-                };
-                await v3pp.executePostProcessorLoop(postCtx);
-                processorResults.push({ name: "v3-post-processor-loop", success: true });
-            }
-        }
-        catch (v3Err) {
-            processorResults.push({ name: "v3-post-processor-loop", success: false, error: String(v3Err) });
-            await frameworkLogger.log("enforcement-gate", "v3-post-processor-error", "warning", {
-                tool,
-                error: String(v3Err),
-            });
-        }
-        // Step 4: Check for proposal-like results
-        let governanceTriggered = false;
-        try {
-            const result = _result;
-            if (result && typeof result === "object" && "title" in result && "description" in result) {
-                const { handleGovernRequest } = await import("../nucleus/index.js");
-                const localMode = process.env.XRAY_LOCAL_MODE === "1" || process.env.XRAY_LOCAL_MODE === "true";
-                const governanceResult = await handleGovernRequest({
-                    proposals: [
-                        {
-                            id: `gate-${Date.now()}`,
-                            type: String(result.type || "fix"),
-                            title: String(result.title || ""),
-                            description: String(result.description || ""),
-                            evidence: [],
-                            source: "manual",
-                            metadata: result,
-                        },
-                    ],
-                    options: {
-                        requireExternalDynamo: localMode ? false : undefined,
-                    },
-                });
-                governanceTriggered = governanceResult?.overallDecision === 'approve';
-                if (governanceTriggered) {
-                    await frameworkLogger.log("enforcement-gate", "governance-triggered", "info", {
-                        tool,
-                        proposalTitle: String(result.title),
-                    });
-                }
-            }
-        }
-        catch (govErr) {
-            await frameworkLogger.log("enforcement-gate", "governance-error", "warning", {
-                tool,
-                error: String(govErr),
-            });
-        }
-        await frameworkLogger.log("enforcement-gate", "after-hook-complete", "info", {
-            tool,
-            violations: violations.length,
-            processors: processorResults.length,
-            governanceTriggered,
-            duration: Date.now() - start,
-        });
-        return {
-            processed: true,
-            violations,
-            processorResults,
-            governanceTriggered,
-            duration: Date.now() - start,
-        };
-    }
-    catch (err) {
-        await frameworkLogger.log("enforcement-gate", "after-hook-error", "error", {
-            tool,
-            error: String(err),
-        });
-        return { processed: false, violations: [], processorResults: [], governanceTriggered: false, duration: Date.now() - start };
-    }
-}
-// ── Helpers ────────────────────────────────────────────────────
-async function loadStateManager() {
-    const global = globalThis;
-    if (global.xrayStateManager)
-        return global.xrayStateManager;
-    // xrayStateManager fallback removed in v2.2
-    const candidatePaths = [
-        () => import("../state/state-manager.js"),
-        () => import(/* skip-ts */ "../../node_modules/0xray/dist/state/state-manager.js"),
-    ];
-    for (const load of candidatePaths) {
-        try {
-            const mod = await load();
-            const SM = mod.XrayStateManager;
-            if (SM)
-                return SM;
-        }
-        catch {
-            continue;
-        }
-    }
-    return null;
-}
-async function loadProcessorManager() {
-    const candidatePaths = [
-        () => import("../processors/processor-manager.js"),
-        () => import(/* skip-ts */ "../../node_modules/0xray/dist/processors/processor-manager.js"),
-    ];
-    for (const load of candidatePaths) {
-        try {
-            const mod = await load();
-            return mod.ProcessorManager;
-        }
-        catch {
-            continue;
-        }
-    }
-    return null;
-}