0xray 2.0.0 → 2.1.0

package/src/mcps/knowledge-skills/strategist.server.ts

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

package/src/mcps/knowledge-skills/tech-writer.server.ts

@@ -160,13 +160,13 @@ interface ProjectStructureAnalysis {
   structure: Record<string, unknown>;
 }
 
-class StringRayDocumentationGenerationServer {
+class XrayDocumentationGenerationServer {
   private server: Server;
 
   constructor() {
     this.server = new Server(
       {
-        name: "documentation-generation", version: "1.22.67",
+        name: "documentation-generation", version: "2.0.0",
       },
       {
         capabilities: {
@@ -1053,7 +1053,7 @@ class StringRayDocumentationGenerationServer {
       openapi: "3.0.0",
       info: {
         title: "API Documentation",
-        version: "1.22.67",
+        version: "2.0.0",
         description: "Generated API documentation",
       },
       servers: [
@@ -1631,8 +1631,8 @@ class StringRayDocumentationGenerationServer {
 
 // Run the server if this file is executed directly
 if (import.meta.url === `file://${process.argv[1]}`) {
-  const server = new StringRayDocumentationGenerationServer();
+  const server = new XrayDocumentationGenerationServer();
   server.run().catch(() => {});
 }
 
-export { StringRayDocumentationGenerationServer };
+export { XrayDocumentationGenerationServer };

package/src/mcps/knowledge-skills/testing-best-practices.server.test.ts

@@ -3,37 +3,37 @@
  */
 
 import { describe, it, expect, beforeEach } from "vitest";
-import { StringRayTestingBestPracticesServer } from "./testing-best-practices.server";
+import { XrayTestingBestPracticesServer } from "./testing-best-practices.server";
 import * as fs from "fs";
 import * as path from "path";
 
 describe("testing-best-practices.server integration", () => {
   describe("module exports", () => {
     it("should export server class", () => {
-      expect(StringRayTestingBestPracticesServer).toBeDefined();
-      expect(typeof StringRayTestingBestPracticesServer).toBe("function");
+      expect(XrayTestingBestPracticesServer).toBeDefined();
+      expect(typeof XrayTestingBestPracticesServer).toBe("function");
     });
 
     it("should be able to instantiate the server", () => {
-      const server = new StringRayTestingBestPracticesServer();
+      const server = new XrayTestingBestPracticesServer();
       expect(server).toBeDefined();
     });
 
     it("should have run method", () => {
-      const server = new StringRayTestingBestPracticesServer();
+      const server = new XrayTestingBestPracticesServer();
       expect(typeof server.run).toBe("function");
     });
   });
 
   describe("server structure", () => {
-    let server: StringRayTestingBestPracticesServer;
+    let server: XrayTestingBestPracticesServer;
 
     beforeEach(() => {
-      server = new StringRayTestingBestPracticesServer();
+      server = new XrayTestingBestPracticesServer();
     });
 
     it("should instantiate correctly", () => {
-      expect(server).toBeInstanceOf(StringRayTestingBestPracticesServer);
+      expect(server).toBeInstanceOf(XrayTestingBestPracticesServer);
     });
 
     it("should have run async method", () => {
@@ -42,82 +42,82 @@ describe("testing-best-practices.server integration", () => {
   });
 
   describe("test analysis capabilities", () => {
-    let server: StringRayTestingBestPracticesServer;
+    let server: XrayTestingBestPracticesServer;
 
     beforeEach(() => {
-      server = new StringRayTestingBestPracticesServer();
+      server = new XrayTestingBestPracticesServer();
     });
 
     it("should analyze test coverage", () => {
-      expect(server).toBeInstanceOf(StringRayTestingBestPracticesServer);
+      expect(server).toBeInstanceOf(XrayTestingBestPracticesServer);
     });
 
     it("should identify test gaps", () => {
-      expect(server).toBeInstanceOf(StringRayTestingBestPracticesServer);
+      expect(server).toBeInstanceOf(XrayTestingBestPracticesServer);
     });
 
     it("should provide recommendations", () => {
-      expect(server).toBeInstanceOf(StringRayTestingBestPracticesServer);
+      expect(server).toBeInstanceOf(XrayTestingBestPracticesServer);
     });
   });
 
   describe("test strategy types", () => {
-    let server: StringRayTestingBestPracticesServer;
+    let server: XrayTestingBestPracticesServer;
 
     beforeEach(() => {
-      server = new StringRayTestingBestPracticesServer();
+      server = new XrayTestingBestPracticesServer();
     });
 
     it("should support unit tests", () => {
-      expect(server).toBeInstanceOf(StringRayTestingBestPracticesServer);
+      expect(server).toBeInstanceOf(XrayTestingBestPracticesServer);
     });
 
     it("should support integration tests", () => {
-      expect(server).toBeInstanceOf(StringRayTestingBestPracticesServer);
+      expect(server).toBeInstanceOf(XrayTestingBestPracticesServer);
     });
 
     it("should support e2e tests", () => {
-      expect(server).toBeInstanceOf(StringRayTestingBestPracticesServer);
+      expect(server).toBeInstanceOf(XrayTestingBestPracticesServer);
     });
 
     it("should support performance tests", () => {
-      expect(server).toBeInstanceOf(StringRayTestingBestPracticesServer);
+      expect(server).toBeInstanceOf(XrayTestingBestPracticesServer);
     });
 
     it("should support security tests", () => {
-      expect(server).toBeInstanceOf(StringRayTestingBestPracticesServer);
+      expect(server).toBeInstanceOf(XrayTestingBestPracticesServer);
     });
   });
 
   describe("TDD/BDD implementation", () => {
-    let server: StringRayTestingBestPracticesServer;
+    let server: XrayTestingBestPracticesServer;
 
     beforeEach(() => {
-      server = new StringRayTestingBestPracticesServer();
+      server = new XrayTestingBestPracticesServer();
     });
 
     it("should provide TDD guidance", () => {
-      expect(server).toBeInstanceOf(StringRayTestingBestPracticesServer);
+      expect(server).toBeInstanceOf(XrayTestingBestPracticesServer);
     });
 
     it("should provide BDD guidance", () => {
-      expect(server).toBeInstanceOf(StringRayTestingBestPracticesServer);
+      expect(server).toBeInstanceOf(XrayTestingBestPracticesServer);
     });
 
     it("should suggest test frameworks", () => {
-      expect(server).toBeInstanceOf(StringRayTestingBestPracticesServer);
+      expect(server).toBeInstanceOf(XrayTestingBestPracticesServer);
     });
   });
 
   describe("automation workflows", () => {
-    let server: StringRayTestingBestPracticesServer;
+    let server: XrayTestingBestPracticesServer;
 
     beforeEach(() => {
-      server = new StringRayTestingBestPracticesServer();
+      server = new XrayTestingBestPracticesServer();
     });
 
     it("should calculate automation potential", () => {
-      expect(server).toBeInstanceOf(StringRayTestingBestPracticesServer);
+      expect(server).toBeInstanceOf(XrayTestingBestPracticesServer);
     });
 
     it("should analyze test frameworks", () => {

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

@@ -203,13 +203,13 @@ interface McpToolResponse {
   data?: Record<string, unknown>;
 }
 
-class StringRayTestingBestPracticesServer {
+class XrayTestingBestPracticesServer {
   private server: Server;
 
   constructor() {
     this.server = new Server(
       {
-        name: "testing-best-practices", version: "1.22.67",
+        name: "testing-best-practices", version: "2.0.0",
       },
       {
         capabilities: {
@@ -1225,8 +1225,8 @@ class StringRayTestingBestPracticesServer {
 
 // Run the server if this file is executed directly
 if (import.meta.url === `file://${process.argv[1]}`) {
-  const server = new StringRayTestingBestPracticesServer();
+  const server = new XrayTestingBestPracticesServer();
   server.run().catch(() => {});
 }
 
-export { StringRayTestingBestPracticesServer };
+export { XrayTestingBestPracticesServer };

package/src/mcps/knowledge-skills/testing-strategy.server.test.ts

@@ -5,35 +5,35 @@
 import { describe, it, expect, beforeEach, vi } from "vitest";
 import * as fs from "fs";
 import * as path from "path";
-import StringRayTestingStrategyServer from "./testing-strategy.server";
+import XrayTestingStrategyServer from "./testing-strategy.server";
 
 describe("testing-strategy.server integration", () => {
   describe("module exports", () => {
     it("should export a server class", () => {
-      expect(StringRayTestingStrategyServer).toBeDefined();
-      expect(typeof StringRayTestingStrategyServer).toBe("function");
+      expect(XrayTestingStrategyServer).toBeDefined();
+      expect(typeof XrayTestingStrategyServer).toBe("function");
     });
 
     it("should be able to instantiate the server", () => {
-      const server = new StringRayTestingStrategyServer();
+      const server = new XrayTestingStrategyServer();
       expect(server).toBeDefined();
     });
 
     it("should have run method", () => {
-      const server = new StringRayTestingStrategyServer();
+      const server = new XrayTestingStrategyServer();
       expect(typeof server.run).toBe("function");
     });
   });
 
   describe("server structure", () => {
-    let server: StringRayTestingStrategyServer;
+    let server: XrayTestingStrategyServer;
 
     beforeEach(() => {
-      server = new StringRayTestingStrategyServer();
+      server = new XrayTestingStrategyServer();
     });
 
     it("should instantiate correctly", () => {
-      expect(server).toBeInstanceOf(StringRayTestingStrategyServer);
+      expect(server).toBeInstanceOf(XrayTestingStrategyServer);
     });
 
     it("should have run async method", () => {
@@ -42,10 +42,10 @@ describe("testing-strategy.server integration", () => {
   });
 
   describe("test analysis functionality", () => {
-    let server: StringRayTestingStrategyServer;
+    let server: XrayTestingStrategyServer;
 
     beforeEach(() => {
-      server = new StringRayTestingStrategyServer();
+      server = new XrayTestingStrategyServer();
     });
 
     it("should analyze test coverage for project", () => {
@@ -63,38 +63,38 @@ describe("testing-strategy.server integration", () => {
   });
 
   describe("test strategy generation", () => {
-    let server: StringRayTestingStrategyServer;
+    let server: XrayTestingStrategyServer;
 
     beforeEach(() => {
-      server = new StringRayTestingStrategyServer();
+      server = new XrayTestingStrategyServer();
     });
 
     it("should handle web project type", () => {
-      expect(server).toBeInstanceOf(StringRayTestingStrategyServer);
+      expect(server).toBeInstanceOf(XrayTestingStrategyServer);
     });
 
     it("should handle api project type", () => {
-      expect(server).toBeInstanceOf(StringRayTestingStrategyServer);
+      expect(server).toBeInstanceOf(XrayTestingStrategyServer);
     });
 
     it("should handle mobile project type", () => {
-      expect(server).toBeInstanceOf(StringRayTestingStrategyServer);
+      expect(server).toBeInstanceOf(XrayTestingStrategyServer);
     });
   });
 
   describe("test gap identification", () => {
-    let server: StringRayTestingStrategyServer;
+    let server: XrayTestingStrategyServer;
 
     beforeEach(() => {
-      server = new StringRayTestingStrategyServer();
+      server = new XrayTestingStrategyServer();
     });
 
     it("should accept source files array", () => {
-      expect(server).toBeInstanceOf(StringRayTestingStrategyServer);
+      expect(server).toBeInstanceOf(XrayTestingStrategyServer);
     });
 
     it("should accept existing tests array", () => {
-      expect(server).toBeInstanceOf(StringRayTestingStrategyServer);
+      expect(server).toBeInstanceOf(XrayTestingStrategyServer);
     });
   });
 });

package/src/mcps/knowledge-skills/testing-strategy.server.ts

@@ -129,13 +129,13 @@ interface BaseTestCounts {
   security: number;
 }
 
-class StringRayTestingStrategyServer {
+class XrayTestingStrategyServer {
   private server: Server;
 
   constructor() {
     this.server = new Server(
       {
-        name: "testing-strategy", version: "1.22.67",
+        name: "testing-strategy", version: "2.0.0",
       },
       {
         capabilities: {
@@ -1165,8 +1165,8 @@ describe("${pathModule.basename(sourceFile, ".ts")}", () => {${testCases}
 
 // Start the server if run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
-  const server = new StringRayTestingStrategyServer();
+  const server = new XrayTestingStrategyServer();
   server.run().catch(() => {});
 }
 
-export default StringRayTestingStrategyServer;
+export default XrayTestingStrategyServer;

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

@@ -186,13 +186,13 @@ interface ToolResponse {
   isError?: boolean;
 }
 
-class StringRayUIUXDesignServer {
+class XrayUIUXDesignServer {
   private server: Server;
 
   constructor() {
     this.server = new Server(
       {
-        name: "ui-ux-design", version: "1.22.67",
+        name: "ui-ux-design", version: "2.0.0",
       },
       {
         capabilities: {
@@ -1985,7 +1985,7 @@ Available: ${Object.keys(system.components).length} component types
     await this.server.connect(transport);
     await frameworkLogger.log(
       "ui-ux-design.server",
-      "-strray-ui-ux-design-mcp-server-running-",
+      "-xray-ui-ux-design-mcp-server-running-",
       "info",
       { message: "xray UI/UX Design MCP Server running..." },
     );
@@ -2011,7 +2011,7 @@ Available: ${Object.keys(system.components).length} component types
         clearTimeout(timeout);
         await frameworkLogger.log(
           "ui-ux-design.server",
-          "-strray-mcp-server-shut-down-gracefully-",
+          "-xray-mcp-server-shut-down-gracefully-",
           "info",
           { message: "xray MCP Server shut down gracefully" },
         );
@@ -2069,8 +2069,8 @@ Available: ${Object.keys(system.components).length} component types
 
 // Run the server if this file is executed directly
 if (import.meta.url === `file://${process.argv[1]}`) {
-  const server = new StringRayUIUXDesignServer();
+  const server = new XrayUIUXDesignServer();
   server.run().catch((error) => frameworkLogger.log("mcps/ui-ux-design", "run", "error", { error: String(error) }));
 }
 
-export { StringRayUIUXDesignServer };
+export { XrayUIUXDesignServer };

package/src/mcps/lint.server.ts

@@ -33,13 +33,13 @@ interface LintResults {
   details: string[];
 }
 
-class StringRayLintServer {
+class XrayLintServer {
   private server: Server;
 
   constructor() {
     this.server = new Server(
       {
-        name: "lint", version: "1.22.67",
+        name: "lint", version: "2.0.0",
       },
       {
         capabilities: {
@@ -51,7 +51,7 @@ class StringRayLintServer {
     this.setupToolHandlers();
     void frameworkLogger.log(
       "lint.server",
-      "-strray-lint-mcp-server-initialized-",
+      "-xray-lint-mcp-server-initialized-",
       "info",
       { message: "0xRay Lint MCP Server initialized" },
     );
@@ -467,7 +467,7 @@ ${checkResults.details.map((d) => `• ${d}`).join("\n")}
     await this.server.connect(transport);
     await frameworkLogger.log(
       "lint.server",
-      "-strray-lint-mcp-server-started-",
+      "-xray-lint-mcp-server-started-",
       "info",
       { message: "0xRay Lint MCP Server started" },
     );
@@ -476,8 +476,8 @@ ${checkResults.details.map((d) => `• ${d}`).join("\n")}
 
 // Start the server if run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
-  const server = new StringRayLintServer();
+  const server = new XrayLintServer();
   server.run().catch((error) => frameworkLogger.log("mcps/lint", "run", "error", { error: String(error) }));
 }
 
-export { StringRayLintServer };
+export { XrayLintServer };

package/src/mcps/mcp-client.ts

@@ -344,17 +344,17 @@ export class MCPClient extends EventEmitter {
       ],
       'framework-help': [
         {
-          name: 'strray_get_capabilities',
+          name: 'xray_get_capabilities',
           description: 'Get 0xRay framework capabilities',
           inputSchema: { type: 'object', properties: {} },
         },
         {
-          name: 'strray_get_commands',
+          name: 'xray_get_commands',
           description: 'Get available 0xRay commands',
           inputSchema: { type: 'object', properties: {} },
         },
         {
-          name: 'strray_explain_capability',
+          name: 'xray_explain_capability',
           description: 'Explain a specific capability',
           inputSchema: {
             type: 'object',

package/src/mcps/model-health-check.server.ts

@@ -36,13 +36,13 @@ interface ModelHealthReportData {
   summary: { total: number; healthy: number; issues: number };
 }
 
-class StringRayModelHealthCheckServer {
+class XrayModelHealthCheckServer {
   private server: Server;
 
   constructor() {
     this.server = new Server(
       {
-        name: "model-health-check", version: "1.22.67",
+        name: "model-health-check", version: "2.0.0",
       },
       {
         capabilities: {
@@ -285,8 +285,8 @@ class StringRayModelHealthCheckServer {
 
 // Start the server if this file is run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
-  const server = new StringRayModelHealthCheckServer();
+  const server = new XrayModelHealthCheckServer();
   server.start().catch((error) => frameworkLogger.log("mcps/model-health-check", "run", "error", { error: String(error) }));
 }
 
-export default StringRayModelHealthCheckServer;
+export default XrayModelHealthCheckServer;

package/src/mcps/orchestrator/server.ts

@@ -12,7 +12,7 @@ import {
   ListToolsRequestSchema,
 } from '@modelcontextprotocol/sdk/types.js';
 import { frameworkLogger } from '../../core/framework-logger.js';
-import { StringRayStateManager } from '../../state/state-manager.js';
+import { XrayStateManager } from '../../state/state-manager.js';
 import { MultiAgentOrchestrationCoordinator } from '../../orchestrator/multi-agent-orchestration-coordinator.js';
 
 import { TaskHandler } from './handlers/task-handler.js';
@@ -45,7 +45,7 @@ export class OrchestratorServer {
 
   constructor() {
     // Initialize actual coordinator
-    const stateManager = new StringRayStateManager();
+    const stateManager = new XrayStateManager();
     this.coordinator = new MultiAgentOrchestrationCoordinator(stateManager);
     
     // Initialize handlers

package/src/mcps/performance-analysis.server.ts

@@ -57,14 +57,14 @@ interface ResourceMetrics {
   recommendations: string[];
 }
 
-class StringRayPerformanceAnalysisServer {
+class XrayPerformanceAnalysisServer {
   private server: Server;
   private startTime: number;
 
   constructor() {
     this.server = new Server(
       {
-        name: "performance-analysis", version: "1.22.67",
+        name: "performance-analysis", version: "2.0.0",
       },
       {
         capabilities: {
@@ -708,8 +708,8 @@ ${results.recommendations.map((r) => `• 💡 ${r}`).join("\n") || "No recommen
 
 // Start the server if run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
-  const server = new StringRayPerformanceAnalysisServer();
+  const server = new XrayPerformanceAnalysisServer();
   server.run().catch((error) => frameworkLogger.log("mcps/performance-analysis", "run", "error", { error: String(error) }));
 }
 
-export { StringRayPerformanceAnalysisServer };
+export { XrayPerformanceAnalysisServer };

package/src/mcps/processor-pipeline.server.ts

@@ -87,7 +87,7 @@ interface FrameworkComplianceResult {
   approved: boolean;
 }
 
-class StringRayProcessorPipelineServer {
+class XrayProcessorPipelineServer {
   private server: Server;
   private codexLoader: CodexLoader;
   private codexRules: RuleDefinition[] = [];
@@ -107,7 +107,7 @@ class StringRayProcessorPipelineServer {
     this.codexLoader = new CodexLoader();
     this.server = new Server(
       {
-        name: "processor-pipeline", version: "1.22.67",
+        name: "processor-pipeline", version: "2.0.0",
       },
       {
         capabilities: {
@@ -771,8 +771,8 @@ ${complianceResults.actions.map((a: string) => `• 🔧 ${a}`).join("\n") || "N
 
 // Start the server if run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
-  const server = new StringRayProcessorPipelineServer();
+  const server = new XrayProcessorPipelineServer();
   server.run().catch((error) => frameworkLogger.log("mcps/processor-pipeline", "run", "error", { error: String(error) }));
 }
 
-export { StringRayProcessorPipelineServer };
+export { XrayProcessorPipelineServer };

package/src/mcps/registry.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.22.67",
+  "version": "2.0.0",
   "description": "0xRay Community MCPs Registry - curated API-focused MCP servers",
   "sources": [
     {

package/src/mcps/researcher.server.ts

@@ -4,7 +4,7 @@
  * Knowledge skill for codebase documentation lookup, implementation examples,
  * and multi-repo analysis - serves as the universal documentation reference
  *
- * NOTE: Class is named StringRayLibrarianServer but the MCP server name is
+ * NOTE: Class is named XrayLibrarianServer but the MCP server name is
  * "researcher" for backwards compatibility with existing tool references.
  */
 
@@ -48,13 +48,13 @@ interface AnalyzeProposalArgs {
   proposalType?: string;
 }
 
-class StringRayLibrarianServer {
+class XrayLibrarianServer {
   private server: Server;
 
   constructor() {
     this.server = new Server(
       {
-        name: "researcher", version: "1.22.67",
+        name: "researcher", version: "2.0.0",
       },
       {
         capabilities: {
@@ -588,8 +588,8 @@ class StringRayLibrarianServer {
 
 // Run the server if this file is executed directly
 if (import.meta.url === `file://${process.argv[1]}`) {
-  const server = new StringRayLibrarianServer();
+  const server = new XrayLibrarianServer();
   server.run().catch((error) => frameworkLogger.log("mcps/researcher", "run", "error", { error: String(error) }));
 }
 
-export { StringRayLibrarianServer };
+export { XrayLibrarianServer };

package/src/mcps/security-scan.server.ts

@@ -39,13 +39,13 @@ interface SecuritySummaryResults {
   summary: string;
 }
 
-class StringRaySecurityScanServer {
+class XraySecurityScanServer {
   private server: Server;
 
   constructor() {
     this.server = new Server(
       {
-        name: "security-scan", version: "1.22.67",
+        name: "security-scan", version: "2.0.0",
       },
       {
         capabilities: {
@@ -644,8 +644,8 @@ ${results.recommendations.map((r) => `• ${r}`).join("\n") || "No recommendatio
 
 // Start the server if run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
-  const server = new StringRaySecurityScanServer();
+  const server = new XraySecurityScanServer();
   server.run().catch((error) => frameworkLogger.log("mcps/security-scan", "run", "error", { error: String(error) }));
 }
 
-export { StringRaySecurityScanServer };
+export { XraySecurityScanServer };