0xray 3.1.1 → 3.2.0

package/src/mcps/lint.server.ts

@@ -4,15 +4,10 @@
  * Comprehensive ESLint validation and automated code quality checking
  */
 
-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 { execFileSync } from "child_process";
 import fs from "fs";
 import { frameworkLogger } from "../core/framework-logger.js";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 
 interface LintArgs {
   files?: string[];
@@ -33,20 +28,63 @@ interface LintResults {
   details: string[];
 }
 
-class XrayLintServer {
-  private server: Server;
-
+class XrayLintServer extends XrayKnowledgeSkillBase {
   constructor() {
-    this.server = new Server(
+    super("lint", "3.1.0");
+
+    this.tools = [
       {
-        name: "lint", version: "3.1.0",
+        name: "lint",
+        description:
+          "Comprehensive ESLint validation and automated code quality checking",
+        inputSchema: {
+          type: "object",
+          properties: {
+            files: {
+              type: "array",
+              items: { type: "string" },
+              description:
+                "Specific files to lint (optional - lints all if empty)",
+            },
+            fix: {
+              type: "boolean",
+              default: false,
+              description:
+                "Automatically fix linting issues where possible",
+            },
+            strict: {
+              type: "boolean",
+              default: false,
+              description: "Use strict linting rules",
+            },
+          },
+        },
       },
       {
-        capabilities: {
-          tools: {},
+        name: "lint-check",
+        description: "Check code quality without making changes",
+        inputSchema: {
+          type: "object",
+          properties: {
+            files: {
+              type: "array",
+              items: { type: "string" },
+              description: "Files to check",
+            },
+            rules: {
+              type: "array",
+              items: { type: "string" },
+              description: "Specific ESLint rules to check",
+            },
+          },
         },
       },
-    );
+    ];
+
+    this.handlers = {
+      "lint": async (args) => this.handleLint(args as LintArgs),
+      "lint-check": async (args) => this.handleLintCheck(args as LintCheckArgs),
+    };
 
     this.setupToolHandlers();
     void frameworkLogger.log(
@@ -57,87 +95,6 @@ class XrayLintServer {
     );
   }
 
-  private setupToolHandlers() {
-    // List available tools
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
-          {
-            name: "lint",
-            description:
-              "Comprehensive ESLint validation and automated code quality checking",
-            inputSchema: {
-              type: "object",
-              properties: {
-                files: {
-                  type: "array",
-                  items: { type: "string" },
-                  description:
-                    "Specific files to lint (optional - lints all if empty)",
-                },
-                fix: {
-                  type: "boolean",
-                  default: false,
-                  description:
-                    "Automatically fix linting issues where possible",
-                },
-                strict: {
-                  type: "boolean",
-                  default: false,
-                  description: "Use strict linting rules",
-                },
-              },
-            },
-          },
-          {
-            name: "lint-check",
-            description: "Check code quality without making changes",
-            inputSchema: {
-              type: "object",
-              properties: {
-                files: {
-                  type: "array",
-                  items: { type: "string" },
-                  description: "Files to check",
-                },
-                rules: {
-                  type: "array",
-                  items: { type: "string" },
-                  description: "Specific ESLint rules to check",
-                },
-              },
-            },
-          },
-        ],
-      };
-    });
-
-    // Handle tool calls
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-
-      try {
-        switch (name) {
-          case "lint":
-            return await this.handleLint(args as unknown as LintArgs);
-          case "lint-check":
-            return await this.handleLintCheck(args as unknown as LintCheckArgs);
-          default:
-            throw new Error(`Unknown tool: ${name}`);
-        }
-      } catch (error) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `❌ Tool execution failed: ${error instanceof Error ? error.message : String(error)}`,
-            },
-          ],
-        };
-      }
-    });
-  }
-
   private async handleLint(args: LintArgs) {
     const files = args.files || [];
     const fix = args.fix || false;
@@ -462,16 +419,6 @@ ${checkResults.details.map((d) => `• ${d}`).join("\n")}
 - Fixed: ${results.issues.fixed}`;
   }
 
-  async run() {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    await frameworkLogger.log(
-      "lint.server",
-      "-xray-lint-mcp-server-started-",
-      "info",
-      { message: "0xRay Lint MCP Server started" },
-    );
-  }
 }
 
 // Start the server if run directly

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

@@ -4,16 +4,11 @@
  * Advanced model compatibility validation and dynamic health assessment
  */
 
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { modelRouter } from "../core/model-router.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
 import { execSync } from "child_process";
 import fs from "fs";
 import { frameworkLogger } from "../core/framework-logger.js";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 
 interface ModelHealthCheckArgs {
   models?: string[];
@@ -36,73 +31,47 @@ interface ModelHealthReportData {
   summary: { total: number; healthy: number; issues: number };
 }
 
-class XrayModelHealthCheckServer {
-  private server: Server;
-
+class XrayModelHealthCheckServer extends XrayKnowledgeSkillBase {
   constructor() {
-    this.server = new Server(
-      {
-        name: "model-health-check", version: "3.1.0",
-      },
+    super("model-health-check", "3.1.0");
+
+    this.tools = [
       {
-        capabilities: {
-          tools: {},
+        name: "model-health-check",
+        description:
+          "Advanced model compatibility validation and dynamic health assessment",
+        inputSchema: {
+          type: "object",
+          properties: {
+            models: {
+              type: "array",
+              items: { type: "string" },
+              description:
+                "Specific models to check (optional - checks all configured if empty)",
+            },
+            compatibility: {
+              type: "boolean",
+              default: true,
+              description: "Include compatibility matrix in results",
+            },
+            performance: {
+              type: "boolean",
+              default: true,
+              description: "Include performance metrics in results",
+            },
+          },
         },
       },
-    );
+    ];
+
+    this.handlers = {
+      "model-health-check": async (args) => this.handleModelHealthCheck((args || {}) as ModelHealthCheckArgs),
+    };
 
     this.setupToolHandlers();
     frameworkLogger.log("mcps/model-health-check", "initialize", "info");
   }
 
-  private setupToolHandlers() {
-    // List available tools
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
-          {
-            name: "model-health-check",
-            description:
-              "Advanced model compatibility validation and dynamic health assessment",
-            inputSchema: {
-              type: "object",
-              properties: {
-                models: {
-                  type: "array",
-                  items: { type: "string" },
-                  description:
-                    "Specific models to check (optional - checks all configured if empty)",
-                },
-                compatibility: {
-                  type: "boolean",
-                  default: true,
-                  description: "Include compatibility matrix in results",
-                },
-                performance: {
-                  type: "boolean",
-                  default: true,
-                  description: "Include performance metrics in results",
-                },
-              },
-            },
-          },
-        ],
-      };
-    });
-
-    // Handle tool calls
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-
-      switch (name) {
-        case "model-health-check":
-          return await this.handleModelHealthCheck((args || {}) as unknown as ModelHealthCheckArgs);
-        default:
-          throw new Error(`Unknown tool: ${name}`);
-      }
-    });
-  }
-
   private async handleModelHealthCheck(args: ModelHealthCheckArgs) {
     const models = args.models || [modelRouter.getValidatedModel()];
     const includeCompatibility = args.compatibility !== false;
@@ -276,17 +245,12 @@ class XrayModelHealthCheckServer {
     return report;
   }
 
-  public async start() {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    frameworkLogger.log("mcps/model-health-check", "start", "info");
-  }
 }
 
 // Start the server if this file is run directly
 if (import.meta.url === `file://${fs.realpathSync(process.argv[1]!)}`) {
   const server = new XrayModelHealthCheckServer();
-  server.start().catch((error) => frameworkLogger.log("mcps/model-health-check", "run", "error", { error: String(error) }));
+  server.run().catch((error) => frameworkLogger.log("mcps/model-health-check", "run", "error", { error: String(error) }));
 }
 
 export default XrayModelHealthCheckServer;

package/src/mcps/orchestrator/aside-context.ts

@@ -0,0 +1,245 @@
+/**
+ * AsideContext — bounded subcontext for depth, continuity, and layered exploration
+ *
+ * Enables the orchestrator to spawn sub-investigations that inherit session context,
+ * accumulate structured observations from v3 subsystems (governance, orchestration,
+ * complexity analysis), and feed results back into the governance loop.
+ */
+
+import { frameworkLogger } from "../../core/framework-logger.js";
+import type {
+  AsideContextOptions,
+  AsideObservation,
+  AsideResult,
+  ActiveAside,
+} from "./types.js";
+import type { InferenceCycleResult } from "../../inference/inference-cycle.js";
+import type { OrchestrationResult, ComplexityAnalysis } from "./types.js";
+
+let asideCounter = 0;
+const activeAsides = new Map<string, ActiveAside>();
+
+export function getActiveAsideCount(): number {
+  return activeAsides.size;
+}
+
+export function getActiveAsideIds(): string[] {
+  return Array.from(activeAsides.keys());
+}
+
+export function getAsideState(asideId: string): ActiveAside | undefined {
+  return activeAsides.get(asideId);
+}
+
+export function addObservations(
+  asideId: string,
+  observations: AsideObservation[],
+): boolean {
+  const aside = activeAsides.get(asideId);
+  if (!aside) return false;
+  aside.observations.push(...observations);
+  return true;
+}
+
+export function extractGovernanceObservations(
+  result: InferenceCycleResult,
+): AsideObservation[] {
+  const obs: AsideObservation[] = [];
+  obs.push({
+    key: "governanceCycleId",
+    value: result.cycleId,
+    source: "inference/inference-cycle.ts",
+  });
+  obs.push({
+    key: "governanceVoteCount",
+    value: String(result.votes.length),
+    source: "inference/inference-cycle.ts",
+  });
+  const approved = result.votes.filter((v) => v.decision === "approve").length;
+  const rejected = result.votes.filter((v) => v.decision === "reject").length;
+  obs.push({
+    key: "governanceApprovedCount",
+    value: String(approved),
+    source: "inference/inference-cycle.ts",
+  });
+  obs.push({
+    key: "governanceRejectedCount",
+    value: String(rejected),
+    source: "inference/inference-cycle.ts",
+  });
+  if (result.corpusSummary) {
+    obs.push({
+      key: "corpusSessionCount",
+      value: String(result.corpusSummary.sessions),
+      source: "inference/inference-cycle.ts",
+    });
+    obs.push({
+      key: "corpusPatternCount",
+      value: String(result.corpusSummary.recurringPatterns),
+      source: "inference/inference-cycle.ts",
+    });
+  }
+  return obs;
+}
+
+export function extractOrchestrationObservations(
+  result: OrchestrationResult,
+): AsideObservation[] {
+  const obs: AsideObservation[] = [];
+  obs.push({
+    key: "orchestrationSuccess",
+    value: String(result.success),
+    source: "mcps/orchestrator/types.ts",
+  });
+  obs.push({
+    key: "tasksCompleted",
+    value: String(result.completedTasks),
+    source: "mcps/orchestrator/types.ts",
+  });
+  obs.push({
+    key: "tasksFailed",
+    value: String(result.failedTasks),
+    source: "mcps/orchestrator/types.ts",
+  });
+  obs.push({
+    key: "orchestrationDuration",
+    value: `${result.duration}ms`,
+    source: "mcps/orchestrator/types.ts",
+  });
+  for (const b of result.bottlenecks) {
+    obs.push({
+      key: "bottleneck",
+      value: b.substring(0, 200),
+      source: "mcps/orchestrator/types.ts",
+    });
+  }
+  for (const r of result.recommendations) {
+    obs.push({
+      key: "recommendation",
+      value: r.substring(0, 200),
+      source: "mcps/orchestrator/types.ts",
+    });
+  }
+  return obs;
+}
+
+export function extractComplexityObservations(
+  analysis: ComplexityAnalysis,
+): AsideObservation[] {
+  const obs: AsideObservation[] = [];
+  obs.push({
+    key: "complexityScore",
+    value: String(analysis.overallComplexity),
+    source: "mcps/orchestrator/execution/execution-planner.ts",
+  });
+  obs.push({
+    key: "recommendedStrategy",
+    value: analysis.recommendedStrategy,
+    source: "mcps/orchestrator/execution/execution-planner.ts",
+  });
+  obs.push({
+    key: "parallelPotential",
+    value: String(analysis.parallelPotential),
+    source: "mcps/orchestrator/execution/execution-planner.ts",
+  });
+  obs.push({
+    key: "estimatedDuration",
+    value: `${analysis.estimatedDuration}ms`,
+    source: "mcps/orchestrator/execution/execution-planner.ts",
+  });
+  for (const tc of analysis.taskComplexity) {
+    obs.push({
+      key: `taskComplexity`,
+      value: `${tc.complexity} (${tc.category})`,
+      source: "mcps/orchestrator/execution/execution-planner.ts",
+    });
+  }
+  return obs;
+}
+
+export async function spawnAside(
+  options: AsideContextOptions,
+): Promise<AsideResult> {
+  const asideId = options.parentAsideId
+    ? `${options.parentAsideId}.aside-${++asideCounter}`
+    : `aside-${++asideCounter}-${Date.now()}`;
+  const startTime = Date.now();
+
+  const aside: ActiveAside = {
+    asideId,
+    description: options.description,
+    startedAt: startTime,
+    observations: [],
+    ...(options.inheritedContext !== undefined ? { inheritedContext: options.inheritedContext } : {}),
+    ...(options.parentAsideId !== undefined ? { parentAsideId: options.parentAsideId } : {}),
+    ...(options.sessionId !== undefined ? { sessionId: options.sessionId } : {}),
+    ...(options.priorVerdictContext !== undefined ? { priorVerdictContext: options.priorVerdictContext } : {}),
+  };
+
+  activeAsides.set(asideId, aside);
+
+  frameworkLogger.log("aside-context", "aside-spawn", "info", {
+    asideId,
+    description: options.description,
+    sessionId: options.sessionId,
+    parentAsideId: options.parentAsideId,
+    activeAsideCount: activeAsides.size,
+  });
+
+  if (options.priorVerdictContext) {
+    const decision = options.priorVerdictContext["decision"];
+    if (decision) {
+      aside.observations.push({
+        key: "governanceDecision",
+        value: String(decision),
+        source: "priorVerdictContext",
+      });
+    }
+  }
+
+  const duration = Date.now() - startTime;
+
+  const result: AsideResult = {
+    asideId,
+    description: options.description,
+    success: true,
+    duration,
+    observations: aside.observations,
+    ...(options.priorVerdictContext !== undefined ? { priorVerdictContext: options.priorVerdictContext } : {}),
+  };
+
+  frameworkLogger.log("aside-context", "aside-complete", "info", {
+    asideId,
+    duration,
+    observationCount: aside.observations.length,
+    activeAsideCount: activeAsides.size,
+  });
+
+  return result;
+}
+
+export function closeAside(asideId: string): boolean {
+  const aside = activeAsides.get(asideId);
+  if (!aside) return false;
+  activeAsides.delete(asideId);
+  frameworkLogger.log("aside-context", "aside-closed", "info", {
+    asideId,
+    duration: Date.now() - aside.startedAt,
+    remainingActive: activeAsides.size,
+  });
+  return true;
+}
+
+export function closeAllAsides(): number {
+  const count = activeAsides.size;
+  activeAsides.clear();
+  frameworkLogger.log("aside-context", "aside-close-all", "info", {
+    closedCount: count,
+  });
+  return count;
+}
+
+export function resetAsideContext(): void {
+  activeAsides.clear();
+  asideCounter = 0;
+}

package/src/mcps/orchestrator/handlers/complexity-handler.ts

@@ -6,6 +6,7 @@
 
 import { frameworkLogger } from '../../../core/framework-logger.js';
 import { getExecutionPlanner } from '../execution/execution-planner.js';
+import { addObservations, extractComplexityObservations } from '../aside-context.js';
 import type { OrchestrationTask, ComplexityAnalysis } from '../types.js';
 
 /**
@@ -18,9 +19,10 @@ export class ComplexityHandler {
   /**
    * Handle analyze-complexity request
    */
-  async handleAnalyzeComplexity(args: {
-    tasks: OrchestrationTask[];
-  }): Promise<{ content: Array<{ type: string; text: string }> }> {
+  async handleAnalyzeComplexity(
+    args: { tasks: OrchestrationTask[] },
+    asideId?: string,
+  ): Promise<{ content: Array<{ type: string; text: string }> }> {
     const { tasks = [] } = args;
 
     await frameworkLogger.log(
@@ -34,6 +36,10 @@ export class ComplexityHandler {
       const analysis = await this.planner.analyzeTaskComplexity(tasks);
       const recommendations = this.generateRecommendations(analysis);
 
+      if (asideId) {
+        addObservations(asideId, extractComplexityObservations(analysis));
+      }
+
       return {
         content: [
           {

package/src/mcps/orchestrator/handlers/status-handler.ts

@@ -18,6 +18,8 @@ interface HistoryItem {
 interface StatusHandlerDeps {
   activeTasks: Map<string, unknown>;
   taskHistory: HistoryItem[];
+  asideCount?: number;
+  asideIds?: string[];
 }
 
 /**
@@ -68,7 +70,15 @@ export class StatusHandler {
         status = this.getOverallStatus(deps);
       }
 
-      const response = this.formatStatusResponse(status, detailed);
+      let response = this.formatStatusResponse(status, detailed);
+
+      if (detailed && deps.asideCount !== undefined) {
+        response += `\n\n**Active Aside Contexts:**`;
+        response += `\n• Count: ${deps.asideCount}`;
+        if (deps.asideIds && deps.asideIds.length > 0) {
+          response += `\n• IDs: ${deps.asideIds.join(', ')}`;
+        }
+      }
 
       return { content: [{ type: 'text', text: response }] };
     } catch (error) {

package/src/mcps/orchestrator/handlers/task-handler.ts

@@ -7,11 +7,13 @@
 import { frameworkLogger } from '../../../core/framework-logger.js';
 import { getExecutionPlanner } from '../execution/execution-planner.js';
 import { mcpClientManager } from '../../../mcps/mcp-client.js';
-import type { OrchestrationResult, OrchestrationTask, TaskExecutionResult } from '../types.js';
+import { addObservations, extractOrchestrationObservations } from '../aside-context.js';
+import type { OrchestrationResult, OrchestrationTask } from '../types.js';
 
 export interface TaskHandlerDeps {
   taskHistory: OrchestrationHistoryItem[];
   activeTasks: Map<string, unknown>;
+  asideId?: string;
 }
 
 interface OrchestrationHistoryItem {
@@ -88,6 +90,11 @@ export class TaskHandler {
         orchestrationResult.agentOutputs = results.agentOutputs;
       }
 
+      // Push observations into aside context if active
+      if (deps.asideId) {
+        addObservations(deps.asideId, extractOrchestrationObservations(orchestrationResult));
+      }
+
       // Store in history
       deps.taskHistory.push({
         sessionId,

package/src/mcps/orchestrator/index.ts

@@ -0,0 +1,29 @@
+export { OrchestratorServer, createOrchestratorServer } from './server.js';
+export { TaskHandler } from './handlers/task-handler.js';
+export { ComplexityHandler } from './handlers/complexity-handler.js';
+export { StatusHandler } from './handlers/status-handler.js';
+export {
+  spawnAside,
+  closeAside,
+  closeAllAsides,
+  addObservations,
+  getActiveAsideCount,
+  getActiveAsideIds,
+  getAsideState,
+  resetAsideContext,
+  extractGovernanceObservations,
+  extractOrchestrationObservations,
+  extractComplexityObservations,
+} from './aside-context.js';
+export type {
+  AsideContextOptions,
+  AsideObservation,
+  AsideResult,
+  ActiveAside,
+  OrchestrationTask,
+  OrchestrationResult,
+  OrchestrationStatus,
+  ComplexityAnalysis,
+  TaskExecutionResult,
+  ExecutionPlan,
+} from './types.js';