0xray 4.0.12 → 4.0.13

package/dist/mcps/model-health-check.server.js

@@ -1,201 +0,0 @@
-/**
- * 0xRay Model Health Check MCP Server
- *
- * Advanced model compatibility validation and dynamic health assessment
- */
-import { modelRouter } from "../core/model-router.js";
-import fs from "fs";
-import { frameworkLogger } from "../core/framework-logger.js";
-import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
-class XrayModelHealthCheckServer extends XrayKnowledgeSkillBase {
-    constructor() {
-        super("model-health-check", "3.1.0");
-        this.tools = [
-            {
-                name: "model-health-check",
-                description: "Advanced model compatibility validation and dynamic health assessment",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        models: {
-                            type: "array",
-                            items: { type: "string" },
-                            description: "Specific models to check (optional - checks all configured if empty)",
-                        },
-                        compatibility: {
-                            type: "boolean",
-                            default: true,
-                            description: "Include compatibility matrix in results",
-                        },
-                        performance: {
-                            type: "boolean",
-                            default: true,
-                            description: "Include performance metrics in results",
-                        },
-                    },
-                },
-            },
-        ];
-        this.handlers = {
-            "model-health-check": async (args) => this.handleModelHealthCheck((args || {})),
-        };
-        this.setupToolHandlers();
-        frameworkLogger.log("mcps/model-health-check", "initialize", "info");
-    }
-    async handleModelHealthCheck(args) {
-        const models = args.models || [modelRouter.getValidatedModel()];
-        const includeCompatibility = args.compatibility !== false;
-        const includePerformance = args.performance !== false;
-        const results = {
-            models: [],
-            compatibilityMatrix: {},
-            performanceMetrics: {},
-            summary: {
-                total: models.length,
-                healthy: 0,
-                issues: 0,
-            },
-        };
-        // Check each model
-        for (const model of models) {
-            try {
-                const modelHealth = await this.checkModelHealth(model);
-                results.models.push(modelHealth);
-                if (modelHealth.healthy) {
-                    results.summary.healthy++;
-                }
-                else {
-                    results.summary.issues++;
-                }
-                if (includePerformance &&
-                    modelHealth.latency !== undefined &&
-                    modelHealth.latency !== null) {
-                    results.performanceMetrics[model] = {
-                        latency: modelHealth.latency,
-                        throughput: "N/A",
-                    };
-                }
-            }
-            catch (error) {
-                results.models.push({
-                    model,
-                    healthy: false,
-                    issues: [
-                        `Health check failed: ${error instanceof Error ? error.message : String(error)}`,
-                    ],
-                    latency: undefined,
-                });
-                results.summary.issues++;
-            }
-        }
-        // Generate compatibility matrix if requested
-        if (includeCompatibility && models.length > 1) {
-            results.compatibilityMatrix = this.generateCompatibilityMatrix(models);
-        }
-        // Generate report
-        const report = this.generateHealthReport(results);
-        return {
-            content: [{ type: "text", text: report }],
-        };
-    }
-    async checkModelHealth(model) {
-        // Simulate model health check - in real implementation, this would test actual model connectivity
-        const issues = [];
-        let latency = Math.random() * 1000 + 500; // Simulate 500-1500ms latency
-        // Basic health checks
-        if (!model || !model.includes("/")) {
-            issues.push("Invalid model format");
-        }
-        // Check model format validity
-        const validPrefixes = ["claude-", "gpt-", "gemini-", "llama-", "mistral-"];
-        if (!validPrefixes.some(p => model.includes(p))) {
-            // Unknown model - may have issues
-            if (Math.random() < 0.1) {
-                issues.push("Model may not be available");
-                latency = undefined;
-            }
-        }
-        return {
-            model,
-            healthy: issues.length === 0,
-            issues,
-            latency,
-            timestamp: new Date().toISOString(),
-        };
-    }
-    generateCompatibilityMatrix(models) {
-        const matrix = {};
-        // Generate mock compatibility data
-        for (const model1 of models) {
-            matrix[model1] = {};
-            for (const model2 of models) {
-                // Models are generally compatible with themselves and similar models
-                matrix[model1][model2] =
-                    model1 === model2 || model1.split("/")[0] === model2.split("/")[0];
-            }
-        }
-        return matrix;
-    }
-    generateHealthReport(results) {
-        let report = "# Model Health Check Report\n\n";
-        // Summary
-        report += "## Summary\n";
-        report += `- Total Models: ${results.summary.total}\n`;
-        report += `- Healthy: ${results.summary.healthy}\n`;
-        report += `- Issues: ${results.summary.issues}\n\n`;
-        // Model Status Details
-        report += "## Model Status Details\n";
-        for (const modelResult of results.models) {
-            report += `**${modelResult.model}:**\n`;
-            report += `- Healthy: ${modelResult.healthy ? "Yes" : "No"}\n`;
-            report += `- Issues: ${modelResult.issues?.join(", ") || "None"}\n`;
-            report += `- Latency: ${modelResult.latency || "N/A"}ms\n\n`;
-        }
-        // Compatibility Matrix
-        if (Object.keys(results.compatibilityMatrix).length > 0) {
-            report += "## Compatibility Matrix\n";
-            const firstModel = Object.keys(results.compatibilityMatrix)[0];
-            if (firstModel && results.compatibilityMatrix[firstModel]) {
-                report +=
-                    "| Model \\\\ Model | " +
-                        Object.keys(results.compatibilityMatrix[firstModel]).join(" | ") +
-                        " |\n";
-                report +=
-                    "|---------------|" +
-                        Object.keys(results.compatibilityMatrix[firstModel])
-                            .map(() => "---|")
-                            .join("") +
-                        "\n";
-                for (const model1 of Object.keys(results.compatibilityMatrix)) {
-                    const row = results.compatibilityMatrix[model1];
-                    if (!row)
-                        continue;
-                    report += `| ${model1} |`;
-                    for (const model2 of Object.keys(row)) {
-                        const compatible = row[model2];
-                        report += ` ${compatible ? "✅" : "❌"} |`;
-                    }
-                    report += "\n";
-                }
-            }
-            report += "\n";
-        }
-        // Performance Metrics
-        if (Object.keys(results.performanceMetrics).length > 0) {
-            report += "## Performance Metrics\n";
-            for (const [model, metrics] of Object.entries(results.performanceMetrics)) {
-                const perfMetrics = metrics;
-                report += `**${model}:**\n`;
-                report += `- Average Latency: ${perfMetrics.latency}ms\n`;
-                report += `- Throughput: ${perfMetrics.throughput}\n\n`;
-            }
-        }
-        return report;
-    }
-}
-// Start the server if this file is run directly
-if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
-    const server = new XrayModelHealthCheckServer();
-    server.run().catch((error) => frameworkLogger.log("mcps/model-health-check", "run", "error", { error: String(error) }));
-}
-export default XrayModelHealthCheckServer;

package/dist/mcps/orchestrator/aside-context.d.ts

@@ -1,21 +0,0 @@
-/**
- * AsideContext — bounded subcontext for depth, continuity, and layered exploration
- *
- * Enables the orchestrator to spawn sub-investigations that inherit session context,
- * accumulate structured observations from v3 subsystems (governance, orchestration,
- * complexity analysis), and feed results back into the governance loop.
- */
-import type { AsideContextOptions, AsideObservation, AsideResult, ActiveAside } from "./types.js";
-import type { InferenceCycleResult } from "../../inference/inference-cycle.js";
-import type { OrchestrationResult, ComplexityAnalysis } from "./types.js";
-export declare function getActiveAsideCount(): number;
-export declare function getActiveAsideIds(): string[];
-export declare function getAsideState(asideId: string): ActiveAside | undefined;
-export declare function addObservations(asideId: string, observations: AsideObservation[]): boolean;
-export declare function extractGovernanceObservations(result: InferenceCycleResult): AsideObservation[];
-export declare function extractOrchestrationObservations(result: OrchestrationResult): AsideObservation[];
-export declare function extractComplexityObservations(analysis: ComplexityAnalysis): AsideObservation[];
-export declare function spawnAside(options: AsideContextOptions): Promise<AsideResult>;
-export declare function closeAside(asideId: string): boolean;
-export declare function closeAllAsides(): number;
-export declare function resetAsideContext(): void;

package/dist/mcps/orchestrator/aside-context.js

@@ -1,207 +0,0 @@
-/**
- * AsideContext — bounded subcontext for depth, continuity, and layered exploration
- *
- * Enables the orchestrator to spawn sub-investigations that inherit session context,
- * accumulate structured observations from v3 subsystems (governance, orchestration,
- * complexity analysis), and feed results back into the governance loop.
- */
-import { frameworkLogger } from "../../core/framework-logger.js";
-let asideCounter = 0;
-const activeAsides = new Map();
-export function getActiveAsideCount() {
-    return activeAsides.size;
-}
-export function getActiveAsideIds() {
-    return Array.from(activeAsides.keys());
-}
-export function getAsideState(asideId) {
-    return activeAsides.get(asideId);
-}
-export function addObservations(asideId, observations) {
-    const aside = activeAsides.get(asideId);
-    if (!aside)
-        return false;
-    aside.observations.push(...observations);
-    return true;
-}
-export function extractGovernanceObservations(result) {
-    const obs = [];
-    obs.push({
-        key: "governanceCycleId",
-        value: result.cycleId,
-        source: "inference/inference-cycle.ts",
-    });
-    obs.push({
-        key: "governanceVoteCount",
-        value: String(result.votes.length),
-        source: "inference/inference-cycle.ts",
-    });
-    const approved = result.votes.filter((v) => v.decision === "approve").length;
-    const rejected = result.votes.filter((v) => v.decision === "reject").length;
-    obs.push({
-        key: "governanceApprovedCount",
-        value: String(approved),
-        source: "inference/inference-cycle.ts",
-    });
-    obs.push({
-        key: "governanceRejectedCount",
-        value: String(rejected),
-        source: "inference/inference-cycle.ts",
-    });
-    if (result.corpusSummary) {
-        obs.push({
-            key: "corpusSessionCount",
-            value: String(result.corpusSummary.sessions),
-            source: "inference/inference-cycle.ts",
-        });
-        obs.push({
-            key: "corpusPatternCount",
-            value: String(result.corpusSummary.recurringPatterns),
-            source: "inference/inference-cycle.ts",
-        });
-    }
-    return obs;
-}
-export function extractOrchestrationObservations(result) {
-    const obs = [];
-    obs.push({
-        key: "orchestrationSuccess",
-        value: String(result.success),
-        source: "mcps/orchestrator/types.ts",
-    });
-    obs.push({
-        key: "tasksCompleted",
-        value: String(result.completedTasks),
-        source: "mcps/orchestrator/types.ts",
-    });
-    obs.push({
-        key: "tasksFailed",
-        value: String(result.failedTasks),
-        source: "mcps/orchestrator/types.ts",
-    });
-    obs.push({
-        key: "orchestrationDuration",
-        value: `${result.duration}ms`,
-        source: "mcps/orchestrator/types.ts",
-    });
-    for (const b of result.bottlenecks) {
-        obs.push({
-            key: "bottleneck",
-            value: b.substring(0, 200),
-            source: "mcps/orchestrator/types.ts",
-        });
-    }
-    for (const r of result.recommendations) {
-        obs.push({
-            key: "recommendation",
-            value: r.substring(0, 200),
-            source: "mcps/orchestrator/types.ts",
-        });
-    }
-    return obs;
-}
-export function extractComplexityObservations(analysis) {
-    const obs = [];
-    obs.push({
-        key: "complexityScore",
-        value: String(analysis.overallComplexity),
-        source: "mcps/orchestrator/execution/execution-planner.ts",
-    });
-    obs.push({
-        key: "recommendedStrategy",
-        value: analysis.recommendedStrategy,
-        source: "mcps/orchestrator/execution/execution-planner.ts",
-    });
-    obs.push({
-        key: "parallelPotential",
-        value: String(analysis.parallelPotential),
-        source: "mcps/orchestrator/execution/execution-planner.ts",
-    });
-    obs.push({
-        key: "estimatedDuration",
-        value: `${analysis.estimatedDuration}ms`,
-        source: "mcps/orchestrator/execution/execution-planner.ts",
-    });
-    for (const tc of analysis.taskComplexity) {
-        obs.push({
-            key: `taskComplexity`,
-            value: `${tc.complexity} (${tc.category})`,
-            source: "mcps/orchestrator/execution/execution-planner.ts",
-        });
-    }
-    return obs;
-}
-export async function spawnAside(options) {
-    const asideId = options.parentAsideId
-        ? `${options.parentAsideId}.aside-${++asideCounter}`
-        : `aside-${++asideCounter}-${Date.now()}`;
-    const startTime = Date.now();
-    const aside = {
-        asideId,
-        description: options.description,
-        startedAt: startTime,
-        observations: [],
-        ...(options.inheritedContext !== undefined ? { inheritedContext: options.inheritedContext } : {}),
-        ...(options.parentAsideId !== undefined ? { parentAsideId: options.parentAsideId } : {}),
-        ...(options.sessionId !== undefined ? { sessionId: options.sessionId } : {}),
-        ...(options.priorVerdictContext !== undefined ? { priorVerdictContext: options.priorVerdictContext } : {}),
-    };
-    activeAsides.set(asideId, aside);
-    frameworkLogger.log("aside-context", "aside-spawn", "info", {
-        asideId,
-        description: options.description,
-        sessionId: options.sessionId,
-        parentAsideId: options.parentAsideId,
-        activeAsideCount: activeAsides.size,
-    });
-    if (options.priorVerdictContext) {
-        const decision = options.priorVerdictContext["decision"];
-        if (decision) {
-            aside.observations.push({
-                key: "governanceDecision",
-                value: String(decision),
-                source: "priorVerdictContext",
-            });
-        }
-    }
-    const duration = Date.now() - startTime;
-    const result = {
-        asideId,
-        description: options.description,
-        success: true,
-        duration,
-        observations: aside.observations,
-        ...(options.priorVerdictContext !== undefined ? { priorVerdictContext: options.priorVerdictContext } : {}),
-    };
-    frameworkLogger.log("aside-context", "aside-complete", "info", {
-        asideId,
-        duration,
-        observationCount: aside.observations.length,
-        activeAsideCount: activeAsides.size,
-    });
-    return result;
-}
-export function closeAside(asideId) {
-    const aside = activeAsides.get(asideId);
-    if (!aside)
-        return false;
-    activeAsides.delete(asideId);
-    frameworkLogger.log("aside-context", "aside-closed", "info", {
-        asideId,
-        duration: Date.now() - aside.startedAt,
-        remainingActive: activeAsides.size,
-    });
-    return true;
-}
-export function closeAllAsides() {
-    const count = activeAsides.size;
-    activeAsides.clear();
-    frameworkLogger.log("aside-context", "aside-close-all", "info", {
-        closedCount: count,
-    });
-    return count;
-}
-export function resetAsideContext() {
-    activeAsides.clear();
-    asideCounter = 0;
-}

package/dist/mcps/orchestrator/config/agent-capabilities.d.ts

@@ -1,39 +0,0 @@
-/**
- * Agent Capabilities Configuration
- *
- * Centralized agent capability definitions for orchestration decisions.
- * Enriched at runtime by the active MemoryRoutingProvider (Repertoire, etc.).
- */
-import type { AgentCapability } from '../types.js';
-/**
- * Agent Capabilities Manager
- * Manages agent capabilities for orchestration decisions
- */
-export declare class AgentCapabilitiesManager {
-    private capabilities;
-    private enriched;
-    constructor();
-    private applyMemoryRoutingEnrichment;
-    /**
-     * Get capabilities for a specific agent
-     */
-    getCapabilities(agentType: string): AgentCapability | undefined;
-    /**
-     * Get all registered agent capabilities
-     */
-    getAllCapabilities(): Map<string, AgentCapability>;
-    /**
-     * Register or update agent capabilities
-     */
-    setCapabilities(agentType: string, capability: AgentCapability): void;
-    /**
-     * Select the best agent for a task based on complexity, capabilities, and memory routing.
-     */
-    selectAgentForTask(requiredCapabilities: string[], complexity: number, operationDescription?: string, taskType?: string): string | null;
-    /**
-     * Get all available agents for a given complexity level
-     */
-    getAvailableAgents(complexity: number): string[];
-}
-export declare function getAgentCapabilitiesManager(): AgentCapabilitiesManager;
-export declare function resetAgentCapabilitiesManager(): void;

package/dist/mcps/orchestrator/config/agent-capabilities.js

@@ -1,128 +0,0 @@
-/**
- * Agent Capabilities Configuration
- *
- * Centralized agent capability definitions for orchestration decisions.
- * Enriched at runtime by the active MemoryRoutingProvider (Repertoire, etc.).
- */
-import { AGENT_REGISTRY } from "../../../agents/registry.js";
-import { initializeMemoryRouting } from '../../../memory-routing/index.js';
-import { getProvider, toMemoryCapabilityMap, fromMemoryCapabilityMap, } from './memory-routing-bridge.js';
-import { routeSubagent } from '../../../nucleus/autonomy-kernel.js';
-/** routeSubagent names → AGENT_REGISTRY keys */
-const ROUTE_AGENT_ALIASES = {
-    'code-review': 'code-reviewer',
-    'security-audit': 'security-auditor',
-    'bug-triage': 'bug-triage-specialist',
-    'architect-tools': 'architect',
-};
-function resolveRoutedAgent(routed, capabilities) {
-    const candidate = ROUTE_AGENT_ALIASES[routed] ?? routed;
-    if (capabilities.has(candidate))
-        return candidate;
-    if (capabilities.has(routed))
-        return routed;
-    return null;
-}
-const DEFAULT_AGENT_CAPABILITIES = Object.fromEntries(Object.entries(AGENT_REGISTRY).map(([name, entry]) => [
-    name,
-    {
-        capabilities: entry.capabilities,
-        complexityThreshold: entry.maxComplexity,
-        concurrentTasks: entry.concurrentTasks,
-    },
-]));
-initializeMemoryRouting();
-/**
- * Agent Capabilities Manager
- * Manages agent capabilities for orchestration decisions
- */
-export class AgentCapabilitiesManager {
-    capabilities = new Map();
-    enriched = false;
-    constructor() {
-        Object.entries(DEFAULT_AGENT_CAPABILITIES).forEach(([agent, config]) => {
-            this.capabilities.set(agent, config);
-        });
-        this.applyMemoryRoutingEnrichment();
-    }
-    applyMemoryRoutingEnrichment() {
-        const provider = getProvider();
-        if (provider.id === 'null')
-            return;
-        const memoryCaps = toMemoryCapabilityMap(this.capabilities);
-        const enriched = provider.enhanceAgentCapabilities(memoryCaps);
-        this.capabilities = fromMemoryCapabilityMap(enriched);
-        this.enriched = true;
-    }
-    /**
-     * Get capabilities for a specific agent
-     */
-    getCapabilities(agentType) {
-        return this.capabilities.get(agentType);
-    }
-    /**
-     * Get all registered agent capabilities
-     */
-    getAllCapabilities() {
-        if (!this.enriched)
-            this.applyMemoryRoutingEnrichment();
-        return new Map(this.capabilities);
-    }
-    /**
-     * Register or update agent capabilities
-     */
-    setCapabilities(agentType, capability) {
-        this.capabilities.set(agentType, capability);
-    }
-    /**
-     * Select the best agent for a task based on complexity, capabilities, and memory routing.
-     */
-    selectAgentForTask(requiredCapabilities, complexity, operationDescription = '', taskType = '') {
-        if (taskType.trim()) {
-            const routed = routeSubagent(taskType);
-            const resolved = resolveRoutedAgent(routed, this.capabilities);
-            if (resolved)
-                return resolved;
-        }
-        const provider = getProvider();
-        if (provider.id !== 'null' && operationDescription) {
-            const memoryCaps = toMemoryCapabilityMap(this.getAllCapabilities());
-            return provider.selectAgent(memoryCaps, requiredCapabilities, complexity, operationDescription);
-        }
-        let bestAgent = null;
-        let bestScore = -1;
-        for (const [agent, caps] of this.capabilities) {
-            if (complexity > caps.complexityThreshold)
-                continue;
-            const matchCount = requiredCapabilities.filter((cap) => caps.capabilities.includes(cap)).length;
-            const score = matchCount * 10 + caps.concurrentTasks;
-            if (score > bestScore) {
-                bestScore = score;
-                bestAgent = agent;
-            }
-        }
-        return bestAgent;
-    }
-    /**
-     * Get all available agents for a given complexity level
-     */
-    getAvailableAgents(complexity) {
-        const available = [];
-        for (const [agent, caps] of this.capabilities) {
-            if (complexity <= caps.complexityThreshold) {
-                available.push(agent);
-            }
-        }
-        return available;
-    }
-}
-let capabilitiesManagerInstance = null;
-export function getAgentCapabilitiesManager() {
-    if (!capabilitiesManagerInstance) {
-        capabilitiesManagerInstance = new AgentCapabilitiesManager();
-    }
-    return capabilitiesManagerInstance;
-}
-export function resetAgentCapabilitiesManager() {
-    capabilitiesManagerInstance = null;
-}

package/dist/mcps/orchestrator/config/memory-routing-bridge.d.ts

@@ -1,12 +0,0 @@
-/**
- * Bridge between orchestrator types and the pluggable MemoryRoutingProvider.
- */
-import { type MemoryAgentCapability, type MemoryOrchestrationTask, type MemoryRoutingProvider } from '../../../memory-routing/index.js';
-import type { AgentCapability, OrchestrationTask } from '../types.js';
-export declare function toMemoryCapability(caps: AgentCapability): MemoryAgentCapability;
-export declare function fromMemoryCapability(caps: MemoryAgentCapability): AgentCapability;
-export declare function toMemoryTask(task: OrchestrationTask): MemoryOrchestrationTask;
-export declare function fromMemoryTask(task: MemoryOrchestrationTask): OrchestrationTask;
-export declare function toMemoryCapabilityMap(caps: Map<string, AgentCapability>): Map<string, MemoryAgentCapability>;
-export declare function fromMemoryCapabilityMap(caps: Map<string, MemoryAgentCapability>): Map<string, AgentCapability>;
-export declare function getProvider(): MemoryRoutingProvider;

package/dist/mcps/orchestrator/config/memory-routing-bridge.js

@@ -1,71 +0,0 @@
-/**
- * Bridge between orchestrator types and the pluggable MemoryRoutingProvider.
- */
-import { getMemoryRoutingProviderSync, } from '../../../memory-routing/index.js';
-export function toMemoryCapability(caps) {
-    const result = {
-        capabilities: caps.capabilities,
-        complexityThreshold: caps.complexityThreshold,
-        concurrentTasks: caps.concurrentTasks,
-    };
-    if (caps.memorySignals)
-        result.memorySignals = caps.memorySignals;
-    if (caps.memoryTags)
-        result.memoryTags = caps.memoryTags;
-    return result;
-}
-export function fromMemoryCapability(caps) {
-    const result = {
-        capabilities: caps.capabilities,
-        complexityThreshold: caps.complexityThreshold,
-        concurrentTasks: caps.concurrentTasks,
-    };
-    if (caps.memorySignals)
-        result.memorySignals = caps.memorySignals;
-    if (caps.memoryTags)
-        result.memoryTags = caps.memoryTags;
-    return result;
-}
-export function toMemoryTask(task) {
-    const result = {
-        id: task.id,
-        description: task.description,
-        type: task.type,
-    };
-    if (task.priority)
-        result.priority = task.priority;
-    if (Array.isArray(task.dependencies) && task.dependencies.length > 0) {
-        result.dependencies = task.dependencies;
-    }
-    if (task.estimatedComplexity !== undefined)
-        result.estimatedComplexity = task.estimatedComplexity;
-    if (task.metadata)
-        result.metadata = task.metadata;
-    return result;
-}
-export function fromMemoryTask(task) {
-    const result = {
-        id: task.id,
-        description: task.description,
-        type: task.type,
-    };
-    if (task.priority)
-        result.priority = task.priority;
-    if (task.dependencies)
-        result.dependencies = task.dependencies;
-    if (task.estimatedComplexity !== undefined)
-        result.estimatedComplexity = task.estimatedComplexity;
-    const metadata = task.metadata;
-    if (metadata)
-        result.metadata = metadata;
-    return result;
-}
-export function toMemoryCapabilityMap(caps) {
-    return new Map(Array.from(caps.entries()).map(([k, v]) => [k, toMemoryCapability(v)]));
-}
-export function fromMemoryCapabilityMap(caps) {
-    return new Map(Array.from(caps.entries()).map(([k, v]) => [k, fromMemoryCapability(v)]));
-}
-export function getProvider() {
-    return getMemoryRoutingProviderSync();
-}