0xray 2.1.1 → 2.1.3

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

@@ -1,25 +1,7 @@
-/**
- * Strategist MCP Server
- *
- * Strategic guidance and complex problem-solving for architectural decisions.
- * Provides strategic planning, risk assessment, and technical strategy tools.
- */
-
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+import { frameworkLogger } from "../../core/framework-logger.js";
 import * as path from "path";
 import { fileURLToPath } from "url";
-import { frameworkLogger } from "../../core/framework-logger.js";
-
-interface Tool {
-  name: string;
-  description: string;
-  inputSchema: object;
-}
 
 interface StrategicGuidanceArgs {
   context: string;
@@ -37,130 +19,81 @@ interface ArchitectureReviewArgs {
   requirements?: string[];
 }
 
-class StrategistServer {
-  private server: Server;
-  private tools: Tool[] = [
-    {
-      name: "strategic_guidance",
-      description:
-        "Provide strategic guidance for complex technical decisions, architectural choices, and high-level planning",
-      inputSchema: {
-        type: "object",
-        properties: {
-          context: {
-            type: "string",
-            description: "Technical context or situation requiring strategic analysis",
-          },
-          options: {
-            type: "array",
-            items: { type: "string" },
-            description: "Available options or choices to evaluate",
-          },
-          criteria: {
-            type: "array",
-            items: { type: "string" },
-            description: "Evaluation criteria (e.g., scalability, cost, maintainability)",
-          },
-        },
-        required: ["context"],
-      },
-    },
-    {
-      name: "risk_assessment",
-      description:
-        "Analyze technical decisions for potential risks, vulnerabilities, and failure modes",
-      inputSchema: {
-        type: "object",
-        properties: {
-          decision: {
-            type: "string",
-            description: "Technical decision or change to assess",
-          },
-          scope: {
-            type: "string",
-            enum: ["low", "medium", "high", "critical"],
-            description: "Scope/impact level of the decision",
+class StrategistServer extends XrayKnowledgeSkillBase {
+  constructor() {
+    super("xray/strategist", "2.0.1");
+    this.tools = [
+      {
+        name: "strategic_guidance",
+        description: "Provide strategic guidance for complex technical decisions, architectural choices, and high-level planning",
+        inputSchema: {
+          type: "object",
+          properties: {
+            context: {
+              type: "string",
+              description: "Technical context or situation requiring strategic analysis",
+            },
+            options: {
+              type: "array",
+              items: { type: "string" },
+              description: "Available options or choices to evaluate",
+            },
+            criteria: {
+              type: "array",
+              items: { type: "string" },
+              description: "Evaluation criteria (e.g., scalability, cost, maintainability)",
+            },
           },
+          required: ["context"],
         },
-        required: ["decision"],
       },
-    },
-    {
-      name: "architecture_review",
-      description:
-        "Review architectural decisions against best practices, patterns, and trade-offs",
-      inputSchema: {
-        type: "object",
-        properties: {
-          architecture: {
-            type: "string",
-            description: "Architecture or design pattern being used",
-          },
-          requirements: {
-            type: "array",
-            items: { type: "string" },
-            description: "Key requirements to satisfy",
+      {
+        name: "risk_assessment",
+        description: "Analyze technical decisions for potential risks, vulnerabilities, and failure modes",
+        inputSchema: {
+          type: "object",
+          properties: {
+            decision: {
+              type: "string",
+              description: "Technical decision or change to assess",
+            },
+            scope: {
+              type: "string",
+              enum: ["low", "medium", "high", "critical"],
+              description: "Scope/impact level of the decision",
+            },
           },
+          required: ["decision"],
         },
-        required: ["architecture"],
-      },
-    },
-  ];
-
-  constructor() {
-    this.server = new Server(
-      {
-        name: "xray/strategist", version: "2.0.1",
       },
       {
-        capabilities: {
-          tools: {},
+        name: "architecture_review",
+        description: "Review architectural decisions against best practices, patterns, and trade-offs",
+        inputSchema: {
+          type: "object",
+          properties: {
+            architecture: {
+              type: "string",
+              description: "Architecture or design pattern being used",
+            },
+            requirements: {
+              type: "array",
+              items: { type: "string" },
+              description: "Key requirements to satisfy",
+            },
+          },
+          required: ["architecture"],
         },
       },
-    );
-
+    ];
+    this.handlers = {
+      strategic_guidance: async (args) => this.handleStrategicGuidance(args as unknown as StrategicGuidanceArgs),
+      risk_assessment: async (args) => this.handleRiskAssessment(args as unknown as RiskAssessmentArgs),
+      architecture_review: async (args) => this.handleArchitectureReview(args as unknown as ArchitectureReviewArgs),
+    };
     this.setupToolHandlers();
   }
 
-  private setupToolHandlers() {
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: this.tools.map((tool) => ({
-          name: tool.name,
-          description: tool.description,
-          inputSchema: tool.inputSchema,
-        })),
-      };
-    });
-
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-
-      try {
-        switch (name) {
-          case "strategic_guidance":
-            return await this.handleStrategicGuidance(args as unknown as StrategicGuidanceArgs);
-          case "risk_assessment":
-            return await this.handleRiskAssessment(args as unknown as RiskAssessmentArgs);
-          case "architecture_review":
-            return await this.handleArchitectureReview(args as unknown as ArchitectureReviewArgs);
-          default:
-            throw new Error(`Unknown tool: ${name}`);
-        }
-      } catch (error) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-            },
-          ],
-          isError: true,
-        };
-      }
-    });
-  }
-
   private async handleStrategicGuidance(args: StrategicGuidanceArgs) {
     const { context, options = [], criteria = [] } = args;
 
@@ -192,10 +125,10 @@ class StrategistServer {
     const { decision, scope = "medium" } = args;
 
     const riskLevels: Record<string, string> = {
-      low: "🔵 Low Risk",
-      medium: "🟡 Medium Risk",
-      high: "🟠 High Risk",
-      critical: "🔴 Critical Risk",
+      low: "Low Risk",
+      medium: "Medium Risk",
+      high: "High Risk",
+      critical: "Critical Risk",
     };
 
     const analysis = [
@@ -250,18 +183,14 @@ class StrategistServer {
       content: [{ type: "text", text: analysis.join("\n") }],
     };
   }
-
-  async start() {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    await frameworkLogger.log("mcp-strategist", "server-started", "success");
-  }
 }
 
 const entryPoint = path.resolve(process.argv[1] ?? "");
 if (entryPoint && fileURLToPath(import.meta.url) === entryPoint) {
   const server = new StrategistServer();
-  server.start().catch((error) => frameworkLogger.log("mcps/strategist", "run", "error", { error: String(error) }));
+  server.run("mcp-strategist").catch((error) => {
+    frameworkLogger.log("strategist", "run", "error", { error: error instanceof Error ? error.message : String(error) });
+  });
 }
 
 export { StrategistServer };