0xray 3.4.1 → 3.4.3

package/dist/mcps/orchestrator/types.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Orchestrator MCP Server Types
+ *
+ * Type definitions for the orchestrator MCP server module
+ */
+export interface AgentCapability {
+    capabilities: string[];
+    complexityThreshold: number;
+    concurrentTasks: number;
+    /** Populated by active MemoryRoutingProvider (e.g. Repertoire) */
+    memorySignals?: string[];
+    memoryTags?: string[];
+}
+export interface OrchestrationTaskMetadata {
+    memorySignals?: string[];
+    matchedPrimitives?: string[];
+    synthesisContext?: string;
+    ontologicalTrapDetected?: boolean;
+    memoryProviderId?: string;
+    memorySignalConfidences?: Record<string, number>;
+    memoryAvgConfidence?: number;
+    memoryHighConfidenceTrap?: boolean;
+    memoryComplexityBoost?: number;
+}
+export interface OrchestrationTask {
+    id: string;
+    description: string;
+    type: string;
+    priority?: 'critical' | 'high' | 'medium' | 'low';
+    dependencies?: string[];
+    estimatedComplexity?: number;
+    metadata?: OrchestrationTaskMetadata;
+}
+export interface ExecutionPlan {
+    tasks: OrchestrationTask[];
+    strategy: 'parallel' | 'sequential' | 'optimized';
+    agentAssignments: Map<string, OrchestrationTask[]>;
+    estimatedDuration: number;
+    memoryContext?: Record<string, unknown>;
+}
+export interface OrchestrationResult {
+    sessionId: string;
+    success: boolean;
+    completedTasks: number;
+    failedTasks: number;
+    duration: number;
+    agentUtilization: Record<string, number>;
+    agentOutputs?: Record<string, string>;
+    bottlenecks: string[];
+    recommendations: string[];
+}
+export interface ComplexityAnalysis {
+    overallComplexity: number;
+    recommendedStrategy: string;
+    taskComplexity: Array<{
+        complexity: number;
+        category: string;
+    }>;
+    agentAssignments: Array<{
+        agent: string;
+        taskCount: number;
+        utilization: number;
+    }>;
+    estimatedDuration: number;
+    parallelPotential: number;
+}
+export interface TaskValidation {
+    valid: boolean;
+    errors: string[];
+}
+export interface ActiveAside {
+    asideId: string;
+    description: string;
+    sessionId?: string;
+    parentAsideId?: string;
+    startedAt: number;
+    inheritedContext?: Record<string, unknown>;
+    priorVerdictContext?: Record<string, unknown>;
+    observations: AsideObservation[];
+}
+export interface AsideObservation {
+    key: string;
+    value: string;
+    source: string;
+}
+export interface AsideContextOptions {
+    description: string;
+    inheritedContext?: Record<string, unknown>;
+    priorVerdictContext?: Record<string, unknown>;
+    sessionId?: string;
+    parentAsideId?: string;
+}
+export interface AsideResult {
+    asideId: string;
+    description: string;
+    success: boolean;
+    duration: number;
+    observations: AsideObservation[];
+    priorVerdictContext?: Record<string, unknown>;
+    error?: string;
+}
+export interface OrchestrationStatus {
+    activeSessions: number;
+    totalTasks: number;
+    agentUtilization: Record<string, number>;
+    recentSessions: Array<{
+        sessionId: string;
+        status: string;
+        tasks: number;
+        duration: number;
+    }>;
+    activeAsideCount?: number;
+    activeAsideIds?: string[];
+}
+export interface TaskExecutionContext {
+    sessionId: string;
+    task: OrchestrationTask;
+    assignedAgent: string;
+    startTime: number;
+}
+/** Result of actually executing one task via an agent/MCP server */
+export interface TaskExecutionResult {
+    taskId: string;
+    agent: string;
+    success: boolean;
+    output: string;
+    durationMs: number;
+}

package/dist/mcps/orchestrator.server.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 0xRay Orchestrator MCP Server
+ *
+ * This is a re-export from the new modular structure.
+ * For the full implementation, see: src/mcps/orchestrator/
+ *
+ * @deprecated Use src/mcps/orchestrator/server.ts instead
+ */
+export { OrchestratorServer, createOrchestratorServer } from './orchestrator/server.js';
+export type { AgentCapability, OrchestrationTask, ExecutionPlan, OrchestrationResult, ComplexityAnalysis, TaskValidation, OrchestrationStatus, TaskExecutionContext, } from './orchestrator/types.js';

package/dist/mcps/performance-analysis.server.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 0xRay Performance Analysis MCP Server
+ *
+ * Comprehensive metrics analysis for framework integration and optimization
+ */
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+declare class XrayPerformanceAnalysisServer extends XrayKnowledgeSkillBase {
+    private startTime;
+    constructor();
+    private handlePerformanceAnalysis;
+    private handleBottleneckDetection;
+    private analyzeRuntimePerformance;
+    private analyzeBuildPerformance;
+    private analyzeResourceUsage;
+    private detectBottlenecks;
+    private analyzeSpecificBottlenecks;
+    private getDiskUsage;
+    private identifyCommonBottlenecks;
+    private findLargeFiles;
+    private checkPerformanceThresholds;
+    private generatePerformanceSummary;
+    private formatMetrics;
+    private generateDetailedReport;
+}
+export { XrayPerformanceAnalysisServer };

package/dist/mcps/processor-pipeline.server.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 0xRay Processor Pipeline MCP Server
+ *
+ * Advanced processor pipeline with codex validation, compliance monitoring, and framework enforcement
+ */
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+declare class XrayProcessorPipelineServer extends XrayKnowledgeSkillBase {
+    private codexLoader;
+    private codexRules;
+    private codexTerms;
+    constructor();
+    private loadCodexRules;
+    private handlePreProcessors;
+    private handlePostProcessors;
+    private handleCodexValidation;
+    private handleComplianceCheck;
+    private sanitizeInput;
+    private validateAgainstCodex;
+    private checkCodexTerm;
+    private enrichWithContext;
+    private performSecurityChecks;
+    private validateResults;
+    private enforceCompliance;
+    private generateAuditTrail;
+    private performQualityAssurance;
+    private detectContentType;
+    private checkFrameworkCompliance;
+}
+export { XrayProcessorPipelineServer };

package/dist/mcps/protocol/protocol-constants.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Protocol Constants
+ *
+ * MCP protocol constants and configuration values.
+ * Extracted to enable reuse and single source of truth.
+ */
+/**
+ * MCP Protocol Version
+ * Current MCP protocol specification version
+ */
+export declare const MCP_PROTOCOL_VERSION = "2024-11-05";
+/**
+ * JSON-RPC Protocol Version
+ * Standard JSON-RPC version used by MCP
+ */
+export declare const JSONRPC_VERSION = "2.0";
+/**
+ * MCP Method Names
+ * Standard MCP protocol method identifiers
+ */
+export declare const MCP_METHODS: {
+    readonly INITIALIZE: "initialize";
+    readonly TOOLS_LIST: "tools/list";
+    readonly TOOLS_CALL: "tools/call";
+};
+/**
+ * Default Timeout Values
+ * Millisecond timeouts for various MCP operations
+ */
+export declare const DEFAULT_TIMEOUTS: {
+    readonly CONNECTION: 30000;
+    readonly REQUEST: 60000;
+    readonly INITIALIZATION: 10000;
+};
+/**
+ * Error Codes
+ * Standard JSON-RPC error codes used by MCP
+ */
+export declare const ERROR_CODES: {
+    readonly PARSE_ERROR: -32700;
+    readonly INVALID_REQUEST: -32600;
+    readonly METHOD_NOT_FOUND: -32601;
+    readonly INVALID_PARAMS: -32602;
+    readonly INTERNAL_ERROR: -32603;
+    readonly SERVER_ERROR: -32000;
+};

package/dist/mcps/researcher-confidence.d.ts

@@ -0,0 +1,21 @@
+import type { MemoryRoutingContext, MemoryTaskConfidence } from '../memory-routing/types.js';
+export interface ResearcherMemoryContext {
+    providerId: string;
+    confidence: MemoryTaskConfidence;
+    matchedSignals: string[];
+    recommendedAgent: string | null;
+    triggeredBy: 'trap-language' | 'high-confidence-primitives';
+}
+export declare function shouldQueryRepertoireConfidence(description: string, proposalType?: string): boolean;
+export declare function hasHighConfidencePrimitiveMatch(routingContext: MemoryRoutingContext, minConfidence?: number): boolean;
+/**
+ * Resolve Repertoire task confidence for researcher proposal analysis.
+ * Triggered by ontological-trap language or high-confidence primitive matches.
+ */
+export declare function resolveResearcherMemoryContext(input: {
+    proposalTitle?: string;
+    proposalDescription?: string;
+    proposalType?: string;
+}): ResearcherMemoryContext | null;
+export declare function buildMemoryRoutingEvidence(context: ResearcherMemoryContext): string[];
+export declare function formatMemoryRoutingBlock(context: ResearcherMemoryContext): string;

package/dist/mcps/researcher.server.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 0xRay Librarian MCP Server
+ *
+ * Knowledge skill for codebase documentation lookup, implementation examples,
+ * and multi-repo analysis - serves as the universal documentation reference
+ *
+ * NOTE: Class is named XrayLibrarianServer but the MCP server name is
+ * "researcher" for backwards compatibility with existing tool references.
+ */
+import { type CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+interface AnalyzeProposalArgs {
+    proposalTitle?: string;
+    proposalDescription?: string;
+    evidence?: string[];
+    proposalType?: string;
+}
+declare class XrayLibrarianServer extends XrayKnowledgeSkillBase {
+    constructor();
+    private searchCodebase;
+    private findImplementation;
+    private getDocumentation;
+    /**
+     * Governance-oriented proposal analysis from the researcher / librarian perspective.
+     * Uses corpus patterns, historical recurrence, and architecture knowledge.
+     */
+    analyzeProposal(args: AnalyzeProposalArgs): Promise<CallToolResult>;
+}
+export { XrayLibrarianServer };

package/dist/mcps/researcher.server.js

@@ -11,11 +11,14 @@ import * as fs from "fs";
 import * as path from "path";
 import { frameworkLogger } from "../core/framework-logger.js";
 import { tryLLMGovernance } from "../governance/llm-governance-provider.js";
+import { initializeMemoryRouting } from "../memory-routing/index.js";
 import { buildMemoryRoutingEvidence, formatMemoryRoutingBlock, resolveResearcherMemoryContext, } from "./researcher-confidence.js";
 import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 class XrayLibrarianServer extends XrayKnowledgeSkillBase {
     constructor() {
         super("researcher", "3.1.0");
+        // Kick off MemoryRoutingProvider load so trap routing is ready in MCP subprocess mode.
+        initializeMemoryRouting();
         this.tools = [
             {
                 name: "search_codebase",

package/dist/mcps/security-scan.server.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 0xRay Security Scan MCP Server
+ *
+ * Automated security vulnerability scanning with dependency and code analysis
+ */
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+declare class XraySecurityScanServer extends XrayKnowledgeSkillBase {
+    constructor();
+    protected setupToolHandlers(): void;
+    private handleSecurityScan;
+    private handleDependencyAudit;
+    private detectPackageManager;
+    private scanDependencies;
+    private scanCodeSecurity;
+    private findCodeFiles;
+    private analyzeFileForSecurity;
+    private generateSecuritySummary;
+}
+export { XraySecurityScanServer };

package/dist/mcps/shared/knowledge-skill-base.d.ts

@@ -0,0 +1,17 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: object;
+}
+export declare class XrayKnowledgeSkillBase {
+    protected tools: ToolDefinition[];
+    protected handlers: Record<string, (args: unknown) => Promise<any>>;
+    protected server: Server;
+    protected serverName: string;
+    constructor(serverName: string, version?: string);
+    protected setupToolHandlers(): void;
+    protected setupListToolsHandler(): void;
+    protected setupCallToolHandler(): void;
+    run(): Promise<void>;
+}

package/dist/mcps/shared/prompt-security-validator.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 0xRay Framework - AI Prompt Security Validator
+ *
+ * Specialized security validation for AI agent prompts and responses
+ * Prevents prompt injection, system prompt override, and malicious inputs
+ */
+export interface PromptSecurityConfig {
+    enabled: boolean;
+    maxPromptLength: number;
+    allowedPatterns: RegExp[];
+    blockedPatterns: RegExp[];
+    sanitizeLevel: "basic" | "strict" | "paranoid";
+}
+export interface SecurityValidationResult {
+    isSafe: boolean;
+    violations: string[];
+    sanitizedPrompt?: string | undefined;
+    riskLevel: "low" | "medium" | "high" | "critical";
+}
+export declare class PromptSecurityValidator {
+    private config;
+    constructor(config?: Partial<PromptSecurityConfig>);
+    /**
+     * Validate AI prompt for security issues
+     */
+    validatePrompt(prompt: string): SecurityValidationResult;
+    /**
+     * Check for system prompt override attempts
+     */
+    private containsSystemPromptOverride;
+    /**
+     * Check for prompt injection attempts
+     */
+    private containsInjectionAttempts;
+    /**
+     * Sanitize prompt by removing dangerous patterns
+     */
+    private sanitizePrompt;
+    /**
+     * Validate agent response for safety
+     */
+    validateResponse(response: string): SecurityValidationResult;
+}
+export declare const promptSecurityValidator: PromptSecurityValidator;

package/dist/mcps/shared/security-scanner.d.ts

@@ -0,0 +1,119 @@
+/**
+ * 0xRay Framework - Security Scanner
+ *
+ * Automated security vulnerability scanning and compliance validation
+ * Integrates with security tools and provides comprehensive security reports
+ */
+export interface SecurityScanConfig {
+    enabled: boolean;
+    tools: {
+        npmAudit: boolean;
+        trivy: boolean;
+        eslintSecurity: boolean;
+        dependencyCheck: boolean;
+    };
+    severityThreshold: "low" | "moderate" | "high" | "critical";
+    reportPath: string;
+    failOnVulnerabilities: boolean;
+}
+export interface SecurityVulnerability {
+    id: string;
+    title: string;
+    description: string;
+    severity: "low" | "moderate" | "high" | "critical";
+    package?: string;
+    version?: string;
+    cve?: string;
+    url?: string;
+    recommendation: string;
+}
+export interface SecurityReport {
+    timestamp: string;
+    duration: number;
+    tools: {
+        npmAudit: SecurityVulnerability[];
+        trivy: SecurityVulnerability[];
+        eslintSecurity: SecurityVulnerability[];
+        dependencyCheck: SecurityVulnerability[];
+    };
+    summary: {
+        totalVulnerabilities: number;
+        bySeverity: Record<string, number>;
+        byTool: Record<string, number>;
+    };
+    recommendations: string[];
+    compliant: boolean;
+}
+export declare class SecurityScanner {
+    private config;
+    constructor(config?: Partial<SecurityScanConfig>);
+    /**
+     * Run comprehensive security scan
+     */
+    runSecurityScan(): Promise<SecurityReport>;
+    /**
+     * Run npm audit
+     */
+    private runNpmAudit;
+    /**
+     * Run Trivy security scan
+     */
+    private runTrivyScan;
+    /**
+     * Run ESLint security rules
+     */
+    private runEslintSecurity;
+    /**
+     * Run OWASP Dependency Check
+     */
+    private runDependencyCheck;
+    /**
+     * Generate comprehensive security report
+     */
+    private generateReport;
+    /**
+     * Generate security recommendations
+     */
+    private generateRecommendations;
+    /**
+     * Save report to file
+     */
+    private saveReport;
+    /**
+     * Log security scan results
+     */
+    private logResults;
+    /**
+     * Map npm audit severity levels
+     */
+    private mapNpmSeverity;
+    /**
+     * Map Trivy severity levels
+     */
+    private mapTrivySeverity;
+    /**
+     * Map Dependency Check severity levels
+     */
+    private mapDependencyCheckSeverity;
+    /**
+     * Validate AI prompt security
+     */
+    validatePrompt(prompt: string): Promise<{
+        isSafe: boolean;
+        violations: string[];
+        riskLevel: string;
+    }>;
+    /**
+     * Validate AI response security
+     */
+    validateResponse(response: string): Promise<{
+        isSafe: boolean;
+        violations: string[];
+        riskLevel: string;
+    }>;
+    /**
+     * Create empty report when scanning is disabled
+     */
+    private createEmptyReport;
+}
+export declare const securityScanner: SecurityScanner;

package/dist/mcps/simulation/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Simulation Module Barrel Export
+ *
+ * Centralized export for all MCP simulation functionality.
+ *
+ * @example
+ * ```typescript
+ * import { SimulationEngine, getAllServerSimulations } from './simulation/index.js';
+ * ```
+ */
+export { SimulationEngine, type SimulatorFunction } from './simulation-engine.js';
+export { getAllServerSimulations, codeReviewSimulations, securityAuditSimulations, performanceOptimizationSimulations, testingStrategySimulations, researcherSimulations, frameworkHelpSimulations, skillInvocationSimulations, type ServerSimulations, } from './server-simulations.js';

package/dist/mcps/simulation/server-simulations.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Server Simulations
+ *
+ * Pre-built simulation implementations for all MCP servers.
+ * Extracted from mcp-client.ts as part of Phase 5 refactoring.
+ */
+import { SimulatorFunction } from './simulation-engine.js';
+export interface ServerSimulations {
+    [serverName: string]: Record<string, SimulatorFunction>;
+}
+/**
+ * Code Review server simulations
+ */
+export declare const codeReviewSimulations: Record<string, SimulatorFunction>;
+/**
+ * Security Audit server simulations
+ */
+export declare const securityAuditSimulations: Record<string, SimulatorFunction>;
+/**
+ * Performance Optimization server simulations
+ */
+export declare const performanceOptimizationSimulations: Record<string, SimulatorFunction>;
+/**
+ * Testing Strategy server simulations
+ */
+export declare const testingStrategySimulations: Record<string, SimulatorFunction>;
+/**
+ * Researcher server simulations
+ */
+export declare const researcherSimulations: Record<string, SimulatorFunction>;
+/**
+ * Framework Help server simulations
+ */
+export declare const frameworkHelpSimulations: Record<string, SimulatorFunction>;
+/**
+ * Skill Invocation server simulations
+ */
+export declare const skillInvocationSimulations: Record<string, SimulatorFunction>;
+export declare function getAllServerSimulations(): ServerSimulations;

package/dist/mcps/simulation/simulation-engine.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Simulation Engine
+ *
+ * Provides fallback simulation for MCP tools when real servers are unavailable.
+ * Part of Phase 5 refactoring - Simulation Layer extraction.
+ */
+import { MCPToolResult, ISimulationEngine } from '../types/index.js';
+export type SimulatorFunction = (args: unknown) => MCPToolResult | Promise<MCPToolResult>;
+export declare class SimulationEngine implements ISimulationEngine {
+    private simulators;
+    /**
+     * Register a simulator for a specific server and tool
+     */
+    registerSimulator(serverName: string, toolName: string, simulator: SimulatorFunction): void;
+    /**
+     * Register multiple simulators for a server
+     */
+    registerServerSimulators(serverName: string, simulators: Record<string, SimulatorFunction>): void;
+    /**
+     * Check if a simulator exists for a server/tool combination
+     */
+    canSimulate(serverName: string, toolName: string): boolean;
+    /**
+     * Execute a simulation
+     */
+    simulate(serverName: string, toolName: string, args: unknown): Promise<MCPToolResult>;
+    /**
+     * Get all registered simulator names for a server
+     */
+    getServerTools(serverName: string): string[];
+    /**
+     * Get all registered server names
+     */
+    getRegisteredServers(): string[];
+    /**
+     * Unregister a specific simulator
+     */
+    unregisterSimulator(serverName: string, toolName: string): boolean;
+    /**
+     * Unregister all simulators for a server
+     */
+    unregisterServer(serverName: string): boolean;
+    /**
+     * Clear all registered simulators
+     */
+    clear(): void;
+    /**
+     * Get total count of registered simulators
+     */
+    getSimulatorCount(): number;
+}

package/dist/mcps/state-manager.server.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 0xRay State Manager MCP Server
+ *
+ * Advanced state management with persistence, synchronization, and conflict resolution
+ */
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+declare class XrayStateManagerServer extends XrayKnowledgeSkillBase {
+    private state;
+    private stateFile;
+    private backups;
+    constructor();
+    private ensureStateDirectory;
+    private loadState;
+    private saveState;
+    setupToolHandlers(): void;
+    private handleGetState;
+    private handleSetState;
+    private handleDeleteState;
+    private handleListState;
+    private handleBackupState;
+    private handleRestoreState;
+    private handleValidateState;
+    private validateStateValue;
+    private repairStateValue;
+    private findDependentKeys;
+}
+export { XrayStateManagerServer };

package/dist/mcps/tools/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Tools Module Barrel Export
+ *
+ * Centralized export for all MCP tool management functionality.
+ *
+ * @example
+ * ```typescript
+ * import { ToolRegistry, ToolDiscovery, ToolExecutor, ToolCache } from './tools/index.js';
+ * ```
+ */
+export { ToolRegistry } from './tool-registry.js';
+export { ToolDiscovery } from './tool-discovery.js';
+export { ToolExecutor } from './tool-executor.js';
+export { ToolCache, type ToolCacheOptions } from './tool-cache.js';