0xray 2.1.4 → 2.2.1

package/dist/cli/server.js

@@ -1,147 +0,0 @@
-import express from "express";
-import { exec } from "child_process";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-import * as fs from "fs";
-import * as crypto from "crypto";
-import { frameworkLogger } from "../core/framework-logger.js";
-import { resolveConfigPath } from "../core/config-paths.js";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const ROOT_DIR = join(__dirname, "..", "..");
-const PUBLIC_DIR = join(ROOT_DIR, "public");
-// Read version dynamically from package.json
-const packageJsonPath = join(ROOT_DIR, "package.json");
-const { version } = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
-const app = express();
-const PORT = 3000;
-const API_KEY = process.env.XRAY_API_KEY || undefined;
-function timingSafeCompare(a, b) {
-    const aBuf = Buffer.from(a, "utf-8");
-    const bBuf = Buffer.from(b, "utf-8");
-    if (aBuf.length !== bBuf.length)
-        return false;
-    return crypto.timingSafeEqual(aBuf, bBuf);
-}
-function requireAuth(req, res, next) {
-    if (!API_KEY) {
-        frameworkLogger.log("cli-server", "auth-skipped", "warning", {
-            message: "No XRAY_API_KEY set — API is unauthenticated. Set XRAY_API_KEY in production.",
-        });
-        return next();
-    }
-    const providedKey = req.headers["x-api-key"];
-    if (typeof providedKey !== "string") {
-        return res.status(401).json({ error: "API key required. Set XRAY_API_KEY environment variable." });
-    }
-    if (!timingSafeCompare(providedKey, API_KEY)) {
-        return res.status(403).json({ error: "Invalid API key" });
-    }
-    next();
-}
-// Lazy load security headers middleware
-let securityMiddleware = null;
-const getSecurityMiddleware = async () => {
-    if (!securityMiddleware) {
-        try {
-            const { securityHeadersMiddleware } = await import("../security/security-headers");
-            securityMiddleware = securityHeadersMiddleware.getExpressMiddleware();
-        }
-        catch (error) {
-            frameworkLogger.log("cli-server", "security-middleware-unavailable", "warning", {
-                message: "Security middleware not available, continuing without security headers",
-            });
-            securityMiddleware = (req, res, next) => next(); // No-op middleware
-        }
-    }
-    return securityMiddleware;
-};
-// Apply security headers middleware lazily
-app.use(async (req, res, next) => {
-    try {
-        const middleware = await getSecurityMiddleware();
-        middleware(req, res, next);
-    }
-    catch (error) {
-        frameworkLogger.log("cli-server", "security-middleware-load-failed", "warning", {
-            error,
-            message: "Security middleware failed to load, continuing without it",
-        });
-        next();
-    }
-});
-// Serve static files
-app.use(express.static(PUBLIC_DIR));
-// API endpoints
-app.get("/api/status", requireAuth, (req, res) => {
-    // Return framework status
-    res.json({
-        framework: "0xRay",
-        version,
-        status: "active",
-        agents: 8,
-        timestamp: new Date().toISOString(),
-    });
-});
-app.get("/api/agents", requireAuth, (req, res) => {
-    // Return agent configurations
-    res.json({
-        agents: [
-            "architect",
-            "bug-triage-specialist",
-            "code-reviewer",
-            "security-auditor",
-            "refactorer",
-            "testing-lead",
-        ],
-    });
-});
-// Performance monitoring middleware
-app.use((req, res, next) => {
-    const start = process.hrtime.bigint();
-    res.on("finish", () => {
-        const end = process.hrtime.bigint();
-        const duration = Number(end - start) / 1e6; // Convert to milliseconds
-        // HTTP request logging - operational, keep for monitoring
-    });
-    next();
-});
-// Add route for root path
-app.get("/", (req, res) => {
-    res.sendFile(join(PUBLIC_DIR, "index.html"));
-});
-// Add route for refactoring logs
-app.get("/logs", requireAuth, async (req, res) => {
-    const logPath = resolveConfigPath("REFACTORING_LOG.md") || join(__dirname, "..", ".xray", "REFACTORING_LOG.md");
-    // Server debug logging - remove for production
-    try {
-        if (fs.existsSync(logPath)) {
-            const content = fs.readFileSync(logPath, "utf-8");
-            res.setHeader("Content-Type", "text/markdown");
-            res.send(content);
-        }
-        else {
-            res
-                .status(404)
-                .send("Refactoring log not found. The framework may not have generated any logs yet.");
-        }
-    }
-    catch (error) {
-        // File read error - remove debug logging
-        res.status(500).send("Server error reading log file.");
-    }
-});
-// Global error handler (4-param middleware must be registered before listen)
-app.use((err, req, res, _next) => {
-    frameworkLogger.log("cli-server", "unhandled-error", "error", { error: err, path: req.path });
-    res.status(500).send("Internal Server Error");
-});
-app.listen(PORT, () => {
-    // Auto-open browser
-    const start = process.platform === "darwin"
-        ? "open"
-        : process.platform === "win32"
-            ? "start"
-            : "xdg-open";
-    exec(`${start} http://localhost:${PORT}`);
-});

package/dist/core/errors.d.ts

@@ -1,3 +0,0 @@
-export declare function logAndReturn<T = never>(logger: any, component: string, message: string, error: unknown, returnValue: T): T;
-export declare function logWarning(logger: any, component: string, message: string, details?: Record<string, unknown>): void;
-export declare function logInfo(logger: any, component: string, message: string, details?: Record<string, unknown>): void;

package/dist/core/errors.js

@@ -1,10 +0,0 @@
-export function logAndReturn(logger, component, message, error, returnValue) {
-    logger.log(component, message, "error", { error: error instanceof Error ? error.message : String(error) }).catch(() => { });
-    return returnValue;
-}
-export function logWarning(logger, component, message, details) {
-    logger.log(component, message, "warning", details).catch(() => { });
-}
-export function logInfo(logger, component, message, details) {
-    logger.log(component, message, "info", details).catch(() => { });
-}

package/dist/core/logging-config.d.ts

@@ -1,11 +0,0 @@
-import type { LogStatus } from "./framework-logger.js";
-export interface LoggingConfig {
-    enabled: boolean;
-    level: "debug" | "info" | "warn" | "error";
-    destinations: ("console" | "file" | "monitoring")[];
-    performanceMode: boolean;
-}
-export declare function getLoggingConfig(): LoggingConfig;
-export declare function setLoggingConfig(config: Partial<LoggingConfig>): void;
-export declare function isLoggingEnabled(): boolean;
-export declare function shouldLog(level: LogStatus): boolean;

package/dist/core/logging-config.js

@@ -1,43 +0,0 @@
-// Default logging configuration
-const defaultLoggingConfig = {
-    enabled: (process.env.XRAY_LOGGING_ENABLED) !== "false", // Default true, can be disabled
-    level: (process.env.XRAY_LOG_LEVEL) || "info",
-    destinations: ["console", "file"],
-    performanceMode: (process.env.XRAY_PERFORMANCE_MODE) === "true",
-};
-// Available log levels in priority order (higher index = more verbose)
-const LOG_LEVELS = ["debug", "info", "warn", "error"];
-// Global logging configuration instance
-let globalLoggingConfig = { ...defaultLoggingConfig };
-export function getLoggingConfig() {
-    return { ...globalLoggingConfig };
-}
-export function setLoggingConfig(config) {
-    globalLoggingConfig = { ...globalLoggingConfig, ...config };
-}
-export function isLoggingEnabled() {
-    return globalLoggingConfig.enabled;
-}
-export function shouldLog(level) {
-    if (!globalLoggingConfig.enabled) {
-        return false;
-    }
-    const currentLevelIndex = LOG_LEVELS.indexOf(globalLoggingConfig.level);
-    const messageLevelIndex = LOG_LEVELS.indexOf(level);
-    // If either level is not found, default to showing the message
-    if (currentLevelIndex === -1 || messageLevelIndex === -1) {
-        return true;
-    }
-    // Show message if its level is >= current configured level
-    return messageLevelIndex >= currentLevelIndex;
-}
-// Environment variable configuration
-if ((process.env.XRAY_LOGGING_ENABLED) === "false") {
-    setLoggingConfig({ enabled: false });
-}
-if (process.env.XRAY_LOG_LEVEL) {
-    setLoggingConfig({ level: (process.env.XRAY_LOG_LEVEL) });
-}
-if ((process.env.XRAY_PERFORMANCE_MODE) === "true") {
-    setLoggingConfig({ performanceMode: true });
-}

package/dist/core/trace-context.d.ts

@@ -1,12 +0,0 @@
-export interface TraceContext {
-    traceId: string;
-    parentId?: string;
-    operation: string;
-    governanceApproved: boolean;
-    startTime: number;
-    metadata?: Record<string, any>;
-}
-export declare function startTrace(operation: string, metadata?: Record<string, any>): TraceContext;
-export declare function getCurrentTrace(): TraceContext | null;
-export declare function endTrace(approved?: boolean): void;
-export declare function propagateTrace(childOperation: string): TraceContext | null;

package/dist/core/trace-context.js

@@ -1,33 +0,0 @@
-// src/core/trace-context.ts
-// Centralized trace propagation
-let currentTrace = null;
-function generateId() {
-    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
-        return crypto.randomUUID();
-    }
-    return Date.now().toString(36) + Math.random().toString(36).substring(2);
-}
-export function startTrace(operation, metadata) {
-    const trace = {
-        traceId: generateId(),
-        operation,
-        governanceApproved: false,
-        startTime: Date.now(),
-        metadata: metadata || {}
-    };
-    currentTrace = trace;
-    return trace;
-}
-export function getCurrentTrace() {
-    return currentTrace;
-}
-export function endTrace(approved = true) {
-    if (currentTrace)
-        currentTrace.governanceApproved = approved;
-    currentTrace = null;
-}
-export function propagateTrace(childOperation) {
-    if (!currentTrace)
-        return null;
-    return { ...currentTrace, parentId: currentTrace.traceId, operation: childOperation, startTime: Date.now() };
-}

package/dist/delegation/voting-coordinator.d.ts

@@ -1,49 +0,0 @@
-/**
- * Voting Coordinator
- *
- * Multi-agent voting system with:
- * - Weighted confidence scoring based on agent expertise
- * - Adaptive strategy selection
- * - Historical learning and pattern detection
- * - Integration with session coordinator
- *
- * @version 1.0.0
- * @since 2026-04-16
- */
-import type { VotingSession, VotingResult, StrategySelectionContext, VotingHistoryEntry, VotingMetrics, ConflictResolutionRequest, ConflictResolutionResponse } from "./voting-types.js";
-import { SessionCoordinator } from "./session-coordinator.js";
-import { WeightedVotingAggregator } from "./weighted-voting-aggregator.js";
-import { XrayStateManager } from "../state/state-manager.js";
-export interface VotingCoordinatorConfig {
-    enableHistoryTracking: boolean;
-    enableLearning: boolean;
-    minVotersForConsensus: number;
-    consensusThreshold: number;
-}
-export declare class VotingCoordinator {
-    private stateManager;
-    private sessionCoordinator;
-    private activeVotingSessions;
-    private votingHistory;
-    private metrics;
-    private config;
-    private aggregator;
-    constructor(stateManager: XrayStateManager, sessionCoordinator?: SessionCoordinator, config?: Partial<VotingCoordinatorConfig>);
-    initiateVoting(sessionId: string, topic: string, description: string, participants: string[], context?: StrategySelectionContext): Promise<string>;
-    submitVote(voteId: string, agentName: string, vote: string, confidence: number, reasoning?: string): boolean;
-    resolveVoting(voteId: string): VotingResult | null;
-    resolveConflict(request: ConflictResolutionRequest): ConflictResolutionResponse;
-    getAggregator(): WeightedVotingAggregator;
-    getVotingSession(voteId: string): VotingSession | undefined;
-    getActiveVotingSessions(): VotingSession[];
-    getVotingHistory(sessionId?: string, limit?: number): VotingHistoryEntry[];
-    getMetrics(): VotingMetrics;
-    private resolveMajorityVote;
-    private resolveConsensus;
-    private resolveExpertPriority;
-    private recordVotingHistory;
-    private loadHistory;
-    private initializeMetrics;
-    private updateMetricsAfterVote;
-}
-export declare const createVotingCoordinator: (stateManager: XrayStateManager, sessionCoordinator?: SessionCoordinator) => VotingCoordinator;