0xray 2.0.0 → 2.0.1

package/dist/mcps/knowledge-skills/refactoring-strategies.server.d.ts

@@ -0,0 +1,33 @@
+/**
+ * xray Refactoring Strategies MCP Server
+ *
+ * Knowledge skill for code refactoring, technical debt elimination,
+ * modernization, and code improvement patterns
+ */
+declare class StringRayRefactoringStrategiesServer {
+    private server;
+    constructor();
+    private setupToolHandlers;
+    private analyzeTechnicalDebt;
+    private suggestRefactoring;
+    private generateRefactoringPlan;
+    private modernizeCodebase;
+    private performTechnicalDebtAnalysis;
+    private analyzeFileForRefactoring;
+    private prioritizeSuggestions;
+    private calculatePriorityScore;
+    private createPrioritizedRefactoringPlan;
+    private analyzeModernizationOpportunities;
+    private calculateDebtScore;
+    private generateDebtRecommendations;
+    private createImplementationPlan;
+    private assessPlanRisks;
+    private defineSuccessMetrics;
+    private createMigrationStrategy;
+    private createRollbackPlan;
+    private getImpactIcon;
+    private getRefactoringIcon;
+    private getMigrationIcon;
+    run(): Promise<void>;
+}
+export { StringRayRefactoringStrategiesServer };

package/dist/mcps/knowledge-skills/refactoring-strategies.server.js

@@ -12,7 +12,7 @@ class StringRayRefactoringStrategiesServer {
     server;
     constructor() {
         this.server = new Server({
-            name: "refactoring-strategies", version: "1.22.67",
+            name: "refactoring-strategies", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},

package/dist/mcps/knowledge-skills/security-audit.server.d.ts

@@ -0,0 +1,48 @@
+/**
+ * xray Security Audit MCP Server
+ *
+ * Knowledge skill for comprehensive security analysis, vulnerability assessment,
+ * and compliance validation - ensures production-ready security posture
+ */
+interface AnalyzeProposalArgs {
+    proposalTitle?: string;
+    proposalDescription?: string;
+    evidence?: string[];
+    proposalType?: string;
+}
+declare class StringRaySecurityAuditServer {
+    private server;
+    constructor();
+    private setupToolHandlers;
+    private auditSecurity;
+    private checkVulnerability;
+    private generateSecurityReport;
+    private analyzeFileForVulnerabilities;
+    private checkInjectionVulnerabilities;
+    private checkAuthVulnerabilities;
+    private checkCryptoVulnerabilities;
+    private checkConfigurationVulnerabilities;
+    private checkDataProtectionVulnerabilities;
+    private checkInputValidationVulnerabilities;
+    private getNextLines;
+    private detectLanguage;
+    private calculateSecuritySummary;
+    private analyzeCompliance;
+    private generateRecommendations;
+    private severityLevel;
+    private mapVulnTypeToCategory;
+    private getSeverityIcon;
+    private generateMarkdownReport;
+    private generateHTMLReport;
+    /**
+     * Governance-oriented proposal analysis from a security perspective.
+     */
+    analyzeProposal(args: AnalyzeProposalArgs): Promise<{
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    run(): Promise<void>;
+}
+export { StringRaySecurityAuditServer };

package/dist/mcps/knowledge-skills/security-audit.server.js

@@ -14,7 +14,7 @@ class StringRaySecurityAuditServer {
     server;
     constructor() {
         this.server = new Server({
-            name: "security-audit", version: "1.22.67",
+            name: "security-audit", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},

package/dist/mcps/knowledge-skills/seo-consultant.server.d.ts

@@ -0,0 +1,26 @@
+/**
+ * SEO Specialist MCP Server
+ *
+ * Technical SEO optimization for code, content, and technical infrastructure.
+ * Provides schema markup, robots.txt, Core Web Vitals, AI search optimization,
+ * sitemap generation, and deep technical SEO audits.
+ */
+declare class SEOSpecialistServer {
+    private server;
+    constructor();
+    private setupToolHandlers;
+    private auditTechnicalSEO;
+    private generateSchemaMarkup;
+    private generateMicrodata;
+    private optimizeCoreWebVitals;
+    private getLCPRecommendation;
+    private getINPRecommendation;
+    private getCLSRecommendation;
+    private analyzeAISearch;
+    private performAIOptimization;
+    private generateSitemap;
+    private optimizeRobotsTxt;
+    private validateRobotsTxt;
+    run(): Promise<void>;
+}
+export { SEOSpecialistServer };

package/dist/mcps/knowledge-skills/seo-consultant.server.js

@@ -12,7 +12,7 @@ import { createGracefulShutdown } from "../../utils/shutdown-handler.js";
 class SEOSpecialistServer {
     server;
     constructor() {
-        this.server = new Server({ name: "seo-consultant", version: "1.22.67" }, { capabilities: { tools: {} } });
+        this.server = new Server({ name: "seo-consultant", version: "2.0.0" }, { capabilities: { tools: {} } });
         this.setupToolHandlers();
     }
     setupToolHandlers() {

package/dist/mcps/knowledge-skills/session-management.server.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Session Management MCP Server
+ *
+ * Tools for managing user sessions and persistent state.
+ * Provides session lifecycle management, state persistence, and cleanup utilities.
+ */
+declare class SessionManagementServer {
+    private server;
+    private sessions;
+    private tools;
+    constructor();
+    private generateSessionId;
+    private isExpired;
+    private handleCreateSession;
+    private handleGetSession;
+    private handleUpdateSession;
+    private handleDeleteSession;
+    private handleListSessions;
+    private handleSessionExists;
+    private handleCleanupExpiredSessions;
+    run(): Promise<void>;
+}
+export default SessionManagementServer;

package/dist/mcps/knowledge-skills/session-management.server.js

@@ -132,7 +132,7 @@ class SessionManagementServer {
         },
     ];
     constructor() {
-        this.server = new Server({ name: "session-management", version: "1.22.67" }, { capabilities: { tools: {} } });
+        this.server = new Server({ name: "session-management", version: "2.0.0" }, { capabilities: { tools: {} } });
         this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
             tools: this.tools,
         }));

package/dist/mcps/knowledge-skills/skill-invocation.server.d.ts

@@ -0,0 +1,29 @@
+declare class SkillInvocationServer {
+    private server;
+    constructor();
+    private setupToolHandlers;
+    private skillMetrics;
+    /**
+     * Record skill invocation outcome for adaptive learning
+     */
+    private recordSkillOutcome;
+    private handleListSkills;
+    private handleInvokeSkill;
+    private handleSkillCodeReview;
+    private handleSkillSecurityAudit;
+    private handleSkillPerformanceOptimization;
+    private handleSkillTestingStrategy;
+    private handleSkillProjectAnalysis;
+    private handleSkillDatabaseDesign;
+    private handleSkillDevopsDeployment;
+    private handleSkillApiDesign;
+    private handleSkillUiUxDesign;
+    private handleSkillDocumentationGeneration;
+    private handleSkillStoryteller;
+    run(): Promise<void>;
+    /**
+     * Run as HTTP server using Streamable HTTP transport (for Grok CLI compatibility).
+     */
+    runHttp(port?: number): Promise<void>;
+}
+export { SkillInvocationServer };

package/dist/mcps/knowledge-skills/skill-invocation.server.js

@@ -12,7 +12,7 @@ class SkillInvocationServer {
     server;
     constructor() {
         this.server = new Server({
-            name: "xray/skill-invocation", version: "1.22.67",
+            name: "xray/skill-invocation", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},

package/dist/mcps/knowledge-skills/strategist.server.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Strategist MCP Server
+ *
+ * Strategic guidance and complex problem-solving for architectural decisions.
+ * Provides strategic planning, risk assessment, and technical strategy tools.
+ */
+declare class StrategistServer {
+    private server;
+    private tools;
+    constructor();
+    private setupToolHandlers;
+    private handleStrategicGuidance;
+    private handleRiskAssessment;
+    private handleArchitectureReview;
+    start(): Promise<void>;
+}
+export { StrategistServer };

package/dist/mcps/knowledge-skills/strategist.server.js

@@ -78,7 +78,7 @@ class StrategistServer {
     ];
     constructor() {
         this.server = new Server({
-            name: "xray/strategist", version: "1.22.67",
+            name: "xray/strategist", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},

package/dist/mcps/knowledge-skills/tech-writer.server.d.ts

@@ -0,0 +1,47 @@
+/**
+ * xray Documentation Generation MCP Server
+ *
+ * Knowledge skill for automated documentation creation, API docs generation,
+ * code documentation maintenance, and technical writing assistance
+ */
+declare class StringRayDocumentationGenerationServer {
+    private server;
+    constructor();
+    private setupToolHandlers;
+    private analyzeDocumentation;
+    private generateAPIDocs;
+    private generateCodeDocumentation;
+    private generateReadme;
+    private performDocumentationAnalysis;
+    private analyzeDocTypeCoverage;
+    private compareDocsWithCode;
+    private analyzeDocumentationQuality;
+    private calculateCompletenessScore;
+    private calculateQualityScore;
+    private generateDocumentationRecommendations;
+    private analyzeAPICode;
+    private extractRoutes;
+    private extractSchemas;
+    private mapTypeScriptType;
+    private generateAPIExamples;
+    private generateErrorCodes;
+    private generateOpenAPISpec;
+    private generateMarkdownAPIDocs;
+    private generateHTMLAPIDocs;
+    private generatePostmanCollection;
+    private analyzeCodeForDocumentation;
+    private extractFunctions;
+    private extractClasses;
+    private hasDocumentation;
+    private generateDocumentationComments;
+    private analyzeProjectStructure;
+    private generateReadmeContent;
+    private generateInstallationSection;
+    private generateUsageSection;
+    private generateAPISection;
+    private generateContributingSection;
+    private generateLicenseSection;
+    private getSeverityIcon;
+    run(): Promise<void>;
+}
+export { StringRayDocumentationGenerationServer };

package/dist/mcps/knowledge-skills/tech-writer.server.js

@@ -14,7 +14,7 @@ class StringRayDocumentationGenerationServer {
     server;
     constructor() {
         this.server = new Server({
-            name: "documentation-generation", version: "1.22.67",
+            name: "documentation-generation", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},
@@ -727,7 +727,7 @@ class StringRayDocumentationGenerationServer {
             openapi: "3.0.0",
             info: {
                 title: "API Documentation",
-                version: "1.22.67",
+                version: "2.0.0",
                 description: "Generated API documentation",
             },
             servers: [

package/dist/mcps/knowledge-skills/testing-best-practices.server.d.ts

@@ -0,0 +1,36 @@
+/**
+ * xray Testing Best Practices MCP Server
+ *
+ * Knowledge skill for comprehensive testing strategies, TDD/BDD implementation,
+ * test coverage optimization, and automated testing workflows
+ */
+declare class StringRayTestingBestPracticesServer {
+    private server;
+    constructor();
+    private setupToolHandlers;
+    private analyzeTestCoverage;
+    private designTestStrategy;
+    private implementTDDWorkflow;
+    private optimizeTestPerformance;
+    private setupCICDTesting;
+    private performCoverageAnalysis;
+    private createTestStrategy;
+    private createTDDWorkflow;
+    private analyzeTestPerformance;
+    private createCIPipeline;
+    private prioritizeGaps;
+    private createCoverageImprovementPlan;
+    private createImplementationRoadmap;
+    private recommendTestingTools;
+    private provideTDDExamples;
+    private recommendTDDResources;
+    private createPerformanceOptimizationPlan;
+    private setupPerformanceMonitoring;
+    private generateCIConfigTemplates;
+    private createCITroubleshootingGuide;
+    private getPriorityIcon;
+    private getImpactIcon;
+    private getTestTypeIcon;
+    run(): Promise<void>;
+}
+export { StringRayTestingBestPracticesServer };

package/dist/mcps/knowledge-skills/testing-best-practices.server.js

@@ -12,7 +12,7 @@ class StringRayTestingBestPracticesServer {
     server;
     constructor() {
         this.server = new Server({
-            name: "testing-best-practices", version: "1.22.67",
+            name: "testing-best-practices", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},

package/dist/mcps/knowledge-skills/testing-strategy.server.d.ts

@@ -0,0 +1,47 @@
+/**
+ * xray Testing Strategy MCP Server
+ *
+ * Knowledge skill for test planning, coverage optimization,
+ * and testing methodology recommendations
+ */
+declare class StringRayTestingStrategyServer {
+    private server;
+    constructor();
+    private setupToolHandlers;
+    private analyzeTestCoverage;
+    private designTestStrategy;
+    private identifyTestGaps;
+    private optimizeTestCoverage;
+    private generateTestFile;
+    private performTestCoverageAnalysis;
+    private generateTestStrategy;
+    private analyzeTestGaps;
+    private createCoverageOptimizationPlan;
+    private findTestFiles;
+    private findSourceFiles;
+    private findFiles;
+    private calculateCoverage;
+    private categorizeTests;
+    private detectTestFrameworks;
+    private analyzeTestPatterns;
+    private identifyCoverageGaps;
+    private generateCoverageRecommendations;
+    private estimateBaseTestCounts;
+    private generateStrategyRecommendations;
+    private createImplementationPlan;
+    private generateExpectedTestFile;
+    private inferTestType;
+    private calculateTestPriority;
+    private estimateTestComplexity;
+    private calculateGapCoverage;
+    private generateGapRecommendations;
+    private estimateOptimizationEffort;
+    private identifyPriorityAreas;
+    private createOptimizationPhases;
+    private estimateOptimizationTimeline;
+    private calculateOptimizationROI;
+    private generateMilestones;
+    private shouldIgnorePath;
+    run(): Promise<void>;
+}
+export default StringRayTestingStrategyServer;

package/dist/mcps/knowledge-skills/testing-strategy.server.js

@@ -16,7 +16,7 @@ class StringRayTestingStrategyServer {
     server;
     constructor() {
         this.server = new Server({
-            name: "testing-strategy", version: "1.22.67",
+            name: "testing-strategy", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},

package/dist/mcps/knowledge-skills/ui-ux-design.server.d.ts

@@ -0,0 +1,69 @@
+/**
+ * xray UI/UX Design MCP Server
+ *
+ * Knowledge skill for user interface and user experience design,
+ * component patterns, accessibility compliance, and design system guidance
+ */
+declare class StringRayUIUXDesignServer {
+    private server;
+    constructor();
+    private setupToolHandlers;
+    private analyzeUIComponent;
+    private designComponent;
+    private auditAccessibility;
+    private generateDesignSystem;
+    private extractComponentName;
+    private analyzeComponentCode;
+    private checkAccessibilityIssues;
+    private checkResponsiveIssues;
+    private checkUsabilityIssues;
+    private checkPerformanceIssues;
+    private checkSemanticIssues;
+    private calculateAccessibilityScore;
+    private calculateUsabilityScore;
+    private generateUIRecommendations;
+    private identifyDesignPatterns;
+    private generateComponentDesign;
+    private generateComponentCode;
+    private generateReactComponent;
+    private generateVueComponent;
+    private generateAngularComponent;
+    private addAccessibilityFeatures;
+    private checkWCAGCompliance;
+    /**
+     * Parse color value and convert to RGB
+     */
+    private parseColor;
+    /**
+     * Calculate relative luminance (WCAG formula)
+     */
+    private getLuminance;
+    private getLuminanceComponent;
+    /**
+     * Calculate contrast ratio between two colors
+     */
+    private calculateContrastRatio;
+    /**
+     * Analyze color contrast in CSS
+     */
+    private analyzeColorContrast;
+    /**
+     * Specifically analyze hero section for contrast issues
+     */
+    private analyzeHeroSectionContrast;
+    /**
+     * Extract CSS for hero section
+     */
+    private extractHeroCSS;
+    private calculateWCAGScore;
+    private generateAccessibilityRecommendations;
+    private createDesignSystem;
+    private generateDesignTokens;
+    private generateDesignSystemDocs;
+    private getSeverityIcon;
+    private validateMobileDesign;
+    private analyzeVisualHierarchy;
+    private recommendImages;
+    run(): Promise<void>;
+}
+export { StringRayUIUXDesignServer };

package/dist/mcps/knowledge-skills/ui-ux-design.server.js

@@ -12,7 +12,7 @@ class StringRayUIUXDesignServer {
     server;
     constructor() {
         this.server = new Server({
-            name: "ui-ux-design", version: "1.22.67",
+            name: "ui-ux-design", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},

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

@@ -0,0 +1,17 @@
+/**
+ * 0xRay Lint MCP Server
+ *
+ * Comprehensive ESLint validation and automated code quality checking
+ */
+declare class StringRayLintServer {
+    private server;
+    constructor();
+    private setupToolHandlers;
+    private handleLint;
+    private handleLintCheck;
+    private runEslint;
+    private checkLintRules;
+    private generateLintSummary;
+    run(): Promise<void>;
+}
+export { StringRayLintServer };

package/dist/mcps/lint.server.js

@@ -13,7 +13,7 @@ class StringRayLintServer {
     server;
     constructor() {
         this.server = new Server({
-            name: "lint", version: "1.22.67",
+            name: "lint", version: "2.0.0",
         }, {
             capabilities: {
                 tools: {},

package/dist/mcps/mcp-client.d.ts

@@ -0,0 +1,157 @@
+/**
+ * MCP Client Layer
+ *
+ * Enables framework components to call MCP servers programmatically.
+ * Refactored as a lean facade using extracted modules (Phases 1-5).
+ *
+ * Architecture:
+ * - ToolRegistry: Manages tool registration and lookup
+ * - ToolDiscovery: Discovers tools from MCP servers
+ * - ToolExecutor: Executes tools via JSON-RPC
+ * - ToolCache: Caches discovered tools
+ * - SimulationEngine: Provides fallback simulations
+ */
+import { EventEmitter } from 'events';
+import { MCPClientConfig, MCPTool, MCPToolResult } from './types/index.js';
+interface RetryConfig {
+    maxRetries: number;
+    initialDelayMs: number;
+    maxDelayMs: number;
+    backoffMultiplier: number;
+}
+/**
+ * Tool event types for hooks
+ */
+export interface ToolBeforeEvent {
+    toolName: string;
+    serverName: string;
+    args: unknown;
+    timestamp: number;
+}
+export interface ToolAfterEvent extends ToolBeforeEvent {
+    result?: MCPToolResult;
+    error?: string;
+    duration: number;
+    success: boolean;
+}
+/**
+ * MCP Client
+ *
+ * Facade that orchestrates tool discovery, caching, execution, and simulation.
+ */
+export declare class MCPClient extends EventEmitter {
+    private config;
+    private toolRegistry;
+    private toolDiscovery;
+    private toolExecutor;
+    private toolCache;
+    private simulationEngine;
+    private retryConfig;
+    constructor(config: MCPClientConfig, retryConfig?: Partial<RetryConfig>);
+    /**
+     * Execute with exponential backoff retry
+     */
+    private executeWithRetry;
+    /**
+     * Execute a tool using the real MCP transport (ConnectionPool + ToolExecutor).
+     * This is the primary production path.
+     */
+    private executeRealTool;
+    /**
+     * Pure MCP mode — simulation and generic fallbacks are disabled.
+     */
+    private get isPureMcpMode();
+    /**
+     * Register default simulation implementations
+     */
+    private registerDefaultSimulations;
+    /**
+     * Initialize MCP client by discovering and caching tools
+     */
+    initialize(): Promise<void>;
+    /**
+     * Discover available tools for this server
+     */
+    private discoverTools;
+    /**
+     * Get static tool definitions for a server
+     */
+    private getStaticTools;
+    /**
+     * Call a specific MCP server tool
+     */
+    callTool(toolName: string, args?: unknown): Promise<MCPToolResult>;
+    /**
+     * Get list of available tools
+     */
+    getAvailableTools(): MCPTool[];
+    /**
+     * Check if a tool is available
+     */
+    hasTool(toolName: string): boolean;
+    /**
+     * Get tool by name
+     */
+    getTool(toolName: string): MCPTool | undefined;
+    /**
+     * Subscribe to tool.before events
+     */
+    onToolBefore(callback: (event: ToolBeforeEvent) => void): void;
+    /**
+     * Subscribe to tool.after events
+     */
+    onToolAfter(callback: (event: ToolAfterEvent) => void): void;
+    /**
+     * Unsubscribe from tool.before events
+     */
+    offToolBefore(callback: (event: ToolBeforeEvent) => void): void;
+    /**
+     * Unsubscribe from tool.after events
+     */
+    offToolAfter(callback: (event: ToolAfterEvent) => void): void;
+}
+/**
+ * MCP Client Manager
+ *
+ * Manages MCP client instances and provides unified interface
+ * for framework components to access MCP server capabilities.
+ */
+export declare class MCPClientManager {
+    private static instance;
+    private clients;
+    private constructor();
+    static getInstance(): MCPClientManager;
+    /**
+     * Get or create MCP client for a server
+     */
+    getClient(serverName: string): Promise<MCPClient>;
+    /**
+     * Get the event emitter for a specific client
+     * Use this to subscribe to tool.before/tool.after events
+     */
+    getClientEventEmitter(serverName: string): MCPClient | null;
+    /**
+     * Subscribe to tool events across all clients
+     * Note: This creates a subscription for each client - manage subscriptions carefully
+     * @returns Unsubscribe function to call to remove all event listeners
+     */
+    onToolEvent(eventType: 'tool.before' | 'tool.after', callback: (event: ToolBeforeEvent | ToolAfterEvent) => void): Promise<() => void>;
+    /**
+     * Create client configuration for a server
+     */
+    createClientConfig(serverName: string): MCPClientConfig;
+    /**
+     * Call MCP server tool
+     */
+    callServerTool(serverName: string, toolName: string, args?: unknown): Promise<MCPToolResult>;
+    /**
+     * Get all available MCP server tools
+     */
+    getAllAvailableTools(): Promise<Record<string, MCPTool[]>>;
+    /**
+     * Clear all cached clients
+     */
+    clearClients(): void;
+}
+export declare const mcpClientManager: MCPClientManager;
+export {};