0xray 2.0.1 → 2.1.1

package/src/mcps/knowledge-skills/security-audit.server.test.ts

@@ -3,37 +3,37 @@
  */
 
 import { describe, it, expect, beforeEach } from "vitest";
-import { StringRaySecurityAuditServer } from "./security-audit.server";
+import { XraySecurityAuditServer } from "./security-audit.server";
 import * as fs from "fs";
 import * as path from "path";
 
 describe("security-audit.server integration", () => {
   describe("module exports", () => {
     it("should export server class", () => {
-      expect(StringRaySecurityAuditServer).toBeDefined();
-      expect(typeof StringRaySecurityAuditServer).toBe("function");
+      expect(XraySecurityAuditServer).toBeDefined();
+      expect(typeof XraySecurityAuditServer).toBe("function");
     });
 
     it("should be able to instantiate the server", () => {
-      const server = new StringRaySecurityAuditServer();
+      const server = new XraySecurityAuditServer();
       expect(server).toBeDefined();
     });
 
     it("should have run method", () => {
-      const server = new StringRaySecurityAuditServer();
+      const server = new XraySecurityAuditServer();
       expect(typeof server.run).toBe("function");
     });
   });
 
   describe("server structure", () => {
-    let server: StringRaySecurityAuditServer;
+    let server: XraySecurityAuditServer;
 
     beforeEach(() => {
-      server = new StringRaySecurityAuditServer();
+      server = new XraySecurityAuditServer();
     });
 
     it("should instantiate correctly", () => {
-      expect(server).toBeInstanceOf(StringRaySecurityAuditServer);
+      expect(server).toBeInstanceOf(XraySecurityAuditServer);
     });
 
     it("should have run async method", () => {
@@ -42,10 +42,10 @@ describe("security-audit.server integration", () => {
   });
 
   describe("security audit capabilities", () => {
-    let server: StringRaySecurityAuditServer;
+    let server: XraySecurityAuditServer;
 
     beforeEach(() => {
-      server = new StringRaySecurityAuditServer();
+      server = new XraySecurityAuditServer();
     });
 
     it("should analyze TypeScript files", () => {
@@ -61,52 +61,52 @@ describe("security-audit.server integration", () => {
     });
 
     it("should detect multiple vulnerability categories", () => {
-      const server = new StringRaySecurityAuditServer();
-      expect(server).toBeInstanceOf(StringRaySecurityAuditServer);
+      const server = new XraySecurityAuditServer();
+      expect(server).toBeInstanceOf(XraySecurityAuditServer);
     });
   });
 
   describe("vulnerability detection", () => {
-    let server: StringRaySecurityAuditServer;
+    let server: XraySecurityAuditServer;
 
     beforeEach(() => {
-      server = new StringRaySecurityAuditServer();
+      server = new XraySecurityAuditServer();
     });
 
     it("should handle injection vulnerabilities", () => {
-      expect(server).toBeInstanceOf(StringRaySecurityAuditServer);
+      expect(server).toBeInstanceOf(XraySecurityAuditServer);
     });
 
     it("should handle authentication vulnerabilities", () => {
-      expect(server).toBeInstanceOf(StringRaySecurityAuditServer);
+      expect(server).toBeInstanceOf(XraySecurityAuditServer);
     });
 
     it("should handle cryptography issues", () => {
-      expect(server).toBeInstanceOf(StringRaySecurityAuditServer);
+      expect(server).toBeInstanceOf(XraySecurityAuditServer);
     });
 
     it("should handle configuration issues", () => {
-      expect(server).toBeInstanceOf(StringRaySecurityAuditServer);
+      expect(server).toBeInstanceOf(XraySecurityAuditServer);
     });
 
     it("should handle data protection issues", () => {
-      expect(server).toBeInstanceOf(StringRaySecurityAuditServer);
+      expect(server).toBeInstanceOf(XraySecurityAuditServer);
     });
   });
 
   describe("compliance checking", () => {
-    let server: StringRaySecurityAuditServer;
+    let server: XraySecurityAuditServer;
 
     beforeEach(() => {
-      server = new StringRaySecurityAuditServer();
+      server = new XraySecurityAuditServer();
     });
 
     it("should check OWASP Top 10 compliance", () => {
-      expect(server).toBeInstanceOf(StringRaySecurityAuditServer);
+      expect(server).toBeInstanceOf(XraySecurityAuditServer);
     });
 
     it("should support multiple compliance frameworks", () => {
-      expect(server).toBeInstanceOf(StringRaySecurityAuditServer);
+      expect(server).toBeInstanceOf(XraySecurityAuditServer);
     });
   });
 });

package/src/mcps/knowledge-skills/security-audit.server.ts

@@ -84,13 +84,13 @@ interface AnalyzeProposalArgs {
   proposalType?: string;
 }
 
-class StringRaySecurityAuditServer {
+class XraySecurityAuditServer {
   private server: Server;
 
   constructor() {
     this.server = new Server(
       {
-        name: "security-audit", version: "2.0.0",
+        name: "security-audit", version: "2.0.1",
       },
       {
         capabilities: {
@@ -1186,8 +1186,8 @@ class StringRaySecurityAuditServer {
 
 // Run the server if this file is executed directly
 if (import.meta.url === `file://${process.argv[1]}`) {
-  const server = new StringRaySecurityAuditServer();
+  const server = new XraySecurityAuditServer();
   server.run().catch(() => {});
 }
 
-export { StringRaySecurityAuditServer };
+export { XraySecurityAuditServer };

package/src/mcps/knowledge-skills/seo-consultant.server.ts

@@ -69,7 +69,7 @@ class SEOSpecialistServer {
 
   constructor() {
     this.server = new Server(
-      { name: "seo-consultant", version: "2.0.0" },
+      { name: "seo-consultant", version: "2.0.1" },
       { capabilities: { tools: {} } },
     );
 

package/src/mcps/knowledge-skills/session-management.server.ts

@@ -161,7 +161,7 @@ class SessionManagementServer {
 
   constructor() {
     this.server = new Server(
-      { name: "session-management", version: "2.0.0" },
+      { name: "session-management", version: "2.0.1" },
       { capabilities: { tools: {} } },
     );
 

package/src/mcps/knowledge-skills/skill-invocation.server.ts

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

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

@@ -110,7 +110,7 @@ class StrategistServer {
   constructor() {
     this.server = new Server(
       {
-        name: "xray/strategist", version: "2.0.0",
+        name: "xray/strategist", version: "2.0.1",
       },
       {
         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: "2.0.0",
+        name: "documentation-generation", version: "2.0.1",
       },
       {
         capabilities: {
@@ -1053,7 +1053,7 @@ class StringRayDocumentationGenerationServer {
       openapi: "3.0.0",
       info: {
         title: "API Documentation",
-        version: "2.0.0",
+        version: "2.0.1",
         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: "2.0.0",
+        name: "testing-best-practices", version: "2.0.1",
       },
       {
         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: "2.0.0",
+        name: "testing-strategy", version: "2.0.1",
       },
       {
         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: "2.0.0",
+        name: "ui-ux-design", version: "2.0.1",
       },
       {
         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: "2.0.0",
+        name: "lint", version: "2.0.1",
       },
       {
         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',