0xray 2.0.0

package/src/mcps/agent-resolver.ts

@@ -0,0 +1,168 @@
+/**
+ * Agent Resolver
+ *
+ * Resolves agent configurations from the 0xRay registry.
+ * Used by the integration layer to programmatically access agent configs.
+ *
+ * @version 1.1.0
+ * @since 2026-02-14
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import { frameworkLogger } from "../core/framework-logger.js";
+
+interface AgentConfig {
+  name: string;
+  description?: string;
+  capabilities?: string[];
+  system?: string;
+  tools?: {
+    include?: string[];
+    exclude?: string[];
+  };
+  model?: string;
+  mode?: string;
+  temperature?: number;
+  maxComplexity?: number;
+  enabled?: boolean;
+  permission?: {
+    edit?: string;
+    bash?: string;
+  };
+  [key: string]: unknown;
+}
+
+interface AgentRegistry {
+  [agentName: string]: AgentConfig;
+}
+
+/**
+ * Resolves an agent configuration by name from the 0xRay registry
+ *
+ * @param agentName - The name of the agent to resolve
+ * @returns The agent configuration object
+ * @throws Error if agent cannot be resolved
+ */
+export async function resolveAgent(agentName: string): Promise<AgentConfig> {
+  // Try to load from the agents registry
+  const registry = await loadAgentRegistry();
+
+  if (registry[agentName]) {
+    return registry[agentName];
+  }
+
+  // Try to load individual agent config file
+  const agentConfig = await loadAgentConfigFile(agentName);
+
+  if (agentConfig) {
+    return agentConfig;
+  }
+
+  // Return default fallback if nothing found
+  await frameworkLogger.log(
+    "agent-resolver",
+    "agent-not-found-using-default",
+    "warning",
+    { agentName },
+  );
+  return {
+    name: agentName,
+    description: "Fallback agent configuration",
+    enabled: true,
+    mode: "subagent",
+  };
+}
+
+/**
+ * Loads the complete agent registry from the index file
+ */
+async function loadAgentRegistry(): Promise<AgentRegistry> {
+  try {
+    // Try to load from the agents index using dynamic import (ESM)
+    const indexPath = path.join(process.cwd(), "dist", "agents", "index.js");
+    const fileUrl = `file://${indexPath}`;
+
+    if (fs.existsSync(indexPath)) {
+      // Dynamic import of the index (ESM)
+      const agentsModule = await import(fileUrl);
+      return agentsModule.builtinAgents || {};
+    }
+  } catch (error) {
+    await frameworkLogger.log(
+      "agent-resolver",
+      "failed-to-load-registry",
+      "warning",
+      { error: String(error) },
+    );
+  }
+
+  return {};
+}
+
+/**
+ * Loads an individual agent configuration file
+ */
+async function loadAgentConfigFile(
+  agentName: string,
+): Promise<AgentConfig | null> {
+  // Map agent names to file paths (kebab-case to camelCase for some agents)
+  const agentFileMap: Record<string, string> = {
+    "bug-triage-specialist": "bugTriageSpecialist",
+    "code-reviewer": "codeReviewer",
+    "testing-lead": "testArchitect",
+    "security-auditor": "securityAuditor",
+  };
+
+  const fileName = agentFileMap[agentName] || agentName;
+  const agentPath = path.join(
+    process.cwd(),
+    "dist",
+    "agents",
+    `${fileName}.js`,
+  );
+  const fileUrl = `file://${agentPath}`;
+
+  try {
+    if (fs.existsSync(agentPath)) {
+      // Dynamic import of the agent file (ESM)
+      const agentModule = await import(fileUrl);
+
+      // Get the export (could be default or named)
+      const camelName = toCamelCase(agentName);
+      return agentModule[camelName] || agentModule.default || null;
+    }
+  } catch (error) {
+    await frameworkLogger.log(
+      "agent-resolver",
+      "failed-to-load-agent-config",
+      "warning",
+      { agentName, error: String(error) },
+    );
+  }
+
+  return null;
+}
+
+/**
+ * Converts a string to camelCase
+ */
+function toCamelCase(str: string): string {
+  return str.replace(/-([a-z])/g, (_g, letter) => letter.toUpperCase());
+}
+
+/**
+ * Gets all available agents from the registry
+ */
+export async function getAllAgents(): Promise<string[]> {
+  const registry = await loadAgentRegistry();
+  return Object.keys(registry);
+}
+
+/**
+ * Checks if an agent exists in the registry
+ */
+export async function agentExists(agentName: string): Promise<boolean> {
+  const registry = await loadAgentRegistry();
+  return agentName in registry;
+}

package/src/mcps/architect-tools.server.ts

@@ -0,0 +1,343 @@
+/**
+ * 0xRay Architect Tools MCP Server
+ *
+ * Converts architect-tools.ts functions into MCP server tools
+ * Provides contextual analysis capabilities via MCP protocol
+ */
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  type CallToolRequest,
+} from "@modelcontextprotocol/sdk/types.js";
+import * as fs from "fs";
+import * as path from "path";
+import { frameworkLogger } from "../core/framework-logger.js";
+import {
+  contextAnalysis as architectContextAnalysis,
+  codebaseStructure as architectCodebaseStructure,
+  dependencyAnalysis as architectDependencyAnalysis,
+  architectureAssessment as architectArchitectureAssessment,
+} from "../architect/architect-tools.js";
+
+interface DirectoryNode {
+  name: string;
+  path: string;
+  type: "directory";
+  children: Array<DirectoryNode | FileNode | { truncated: boolean } | { error: string }>,
+}
+
+interface FileNode {
+  name: string;
+  type: "file";
+  extension: string;
+}
+
+class StringRayArchitectToolsServer {
+  private server: Server;
+
+  constructor() {
+    this.server = new Server(
+      {
+        name: "architect-tools", version: "1.22.67",
+      },
+      {
+        capabilities: {
+          tools: {},
+        },
+      },
+    );
+
+    this.setupToolHandlers();
+    frameworkLogger.log("mcps/architect-tools", "init", "info", { message: "0xRay Architect Tools MCP Server initialized" });
+  }
+
+  private setupToolHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: [
+          {
+            name: "context-analysis",
+            description:
+              "Perform comprehensive codebase intelligence gathering including structure analysis, dependency mapping, and architectural pattern recognition",
+            inputSchema: {
+              type: "object",
+              properties: {
+                projectRoot: {
+                  type: "string",
+                  description: "Root directory of the project to analyze",
+                },
+                depth: {
+                  type: "string",
+                  enum: ["overview", "detailed", "comprehensive"],
+                  default: "detailed",
+                  description: "Analysis depth level",
+                },
+                includeFiles: {
+                  type: "array",
+                  items: { type: "string" },
+                  description: "Specific files to include in analysis",
+                },
+              },
+              required: ["projectRoot"],
+            },
+          },
+          {
+            name: "codebase-structure",
+            description:
+              "Analyze file organization, module distribution, and directory hierarchy with optional metrics",
+            inputSchema: {
+              type: "object",
+              properties: {
+                projectRoot: {
+                  type: "string",
+                  description: "Root directory of the project",
+                },
+                includeMetrics: {
+                  type: "boolean",
+                  default: true,
+                  description: "Include detailed metrics",
+                },
+                maxDepth: {
+                  type: "number",
+                  default: 10,
+                  description: "Maximum directory depth to analyze",
+                },
+              },
+              required: ["projectRoot"],
+            },
+          },
+          {
+            name: "dependency-analysis",
+            description:
+              "Map component dependencies, identify coupling patterns, and assess architectural relationships",
+            inputSchema: {
+              type: "object",
+              properties: {
+                projectRoot: {
+                  type: "string",
+                  description: "Root directory of the project",
+                },
+                focusAreas: {
+                  type: "array",
+                  items: { type: "string" },
+                  description: "Specific areas to focus dependency analysis on",
+                },
+                includeGraphs: {
+                  type: "boolean",
+                  default: true,
+                  description: "Include dependency graphs in output",
+                },
+              },
+              required: ["projectRoot"],
+            },
+          },
+          {
+            name: "architecture-assessment",
+            description:
+              "Evaluate overall architectural health with scores, issues, and improvement recommendations",
+            inputSchema: {
+              type: "object",
+              properties: {
+                projectRoot: {
+                  type: "string",
+                  description: "Root directory of the project",
+                },
+                assessmentType: {
+                  type: "string",
+                  enum: ["quick", "comprehensive"],
+                  default: "comprehensive",
+                  description: "Type of assessment to perform",
+                },
+                focusMetrics: {
+                  type: "array",
+                  items: {
+                    type: "string",
+                    enum: [
+                      "complexity",
+                      "coupling",
+                      "cohesion",
+                      "testability",
+                      "scalability",
+                    ],
+                  },
+                  description: "Specific metrics to focus assessment on",
+                },
+              },
+              required: ["projectRoot"],
+            },
+          },
+        ],
+      };
+    });
+
+    this.server.setRequestHandler(
+      CallToolRequestSchema,
+      async (request: CallToolRequest) => {
+        const { name, arguments: args } = request.params;
+
+        try {
+          switch (name) {
+            case "context-analysis":
+              return await this.contextAnalysis(args);
+            case "codebase-structure":
+              return await this.codebaseStructure(args);
+            case "dependency-analysis":
+              return await this.dependencyAnalysis(args);
+            case "architecture-assessment":
+              return await this.architectureAssessment(args);
+            default:
+              throw new Error(`Unknown tool: ${name}`);
+          }
+        } catch (error) {
+          frameworkLogger.log("mcps/architect-tools", "tool", "error", { tool: name, error: String(error) });
+          throw error;
+        }
+      },
+    );
+  }
+
+  // Tool implementations — delegates to real architect-tools library
+
+  private async contextAnalysis(args: Record<string, unknown> | undefined) {
+    const projectRoot = (args?.projectRoot as string) || "";
+    const depth = (args?.depth as "overview" | "detailed" | "comprehensive") || "detailed";
+    const includeFiles = args?.includeFiles as string[] | undefined;
+
+    frameworkLogger.log("mcps/architect-tools", "context-analysis", "info", { projectRoot });
+
+    const result = await architectContextAnalysis(projectRoot, includeFiles, depth);
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(result, null, 2),
+        },
+      ],
+    };
+  }
+
+  private async codebaseStructure(args: Record<string, unknown> | undefined) {
+    const projectRoot = (args?.projectRoot as string) || "";
+    const includeMetrics = (args?.includeMetrics as boolean) ?? true;
+
+    frameworkLogger.log("mcps/architect-tools", "codebase-structure", "info", { projectRoot });
+
+    const result = await architectCodebaseStructure(projectRoot, includeMetrics);
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(result, null, 2),
+        },
+      ],
+    };
+  }
+
+  private async dependencyAnalysis(args: Record<string, unknown> | undefined) {
+    const projectRoot = (args?.projectRoot as string) || "";
+    const focusAreas = args?.focusAreas as string[] | undefined;
+
+    frameworkLogger.log("mcps/architect-tools", "dependency-analysis", "info", { projectRoot });
+
+    const result = await architectDependencyAnalysis(projectRoot, focusAreas);
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(result, null, 2),
+        },
+      ],
+    };
+  }
+
+  private async architectureAssessment(args: Record<string, unknown> | undefined) {
+    const projectRoot = (args?.projectRoot as string) || "";
+    const assessmentType = (args?.assessmentType as "quick" | "comprehensive") || "comprehensive";
+
+    frameworkLogger.log("mcps/architect-tools", "architecture-assessment", "info", { projectRoot });
+
+    const result = await architectArchitectureAssessment(projectRoot, assessmentType);
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(result, null, 2),
+        },
+      ],
+    };
+  }
+
+  async run(): Promise<void> {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    frameworkLogger.log("mcps/architect-tools", "start", "info");
+
+    const cleanup = async (signal: string) => {
+      frameworkLogger.log("mcps/architect-tools", "shutdown", "info", { signal });
+
+      // Set a timeout to force exit if graceful shutdown fails
+      const timeout = setTimeout(() => {
+        frameworkLogger.log("mcps/architect-tools", "shutdown", "error", { message: "Graceful shutdown timeout, forcing exit..." });
+        process.exit(1);
+      }, 5000); // 5 second timeout
+
+      try {
+        if (this.server && typeof this.server.close === "function") {
+          await this.server.close();
+        }
+        clearTimeout(timeout);
+        frameworkLogger.log("mcps/architect-tools", "shutdown", "success");
+        process.exit(0);
+      } catch (error) {
+        clearTimeout(timeout);
+        frameworkLogger.log("mcps/architect-tools", "shutdown", "error", { message: `Error during server shutdown: ${String(error)}` });
+        process.exit(1);
+      }
+    };
+
+    // Handle multiple shutdown signals
+    process.on("SIGINT", () => cleanup("SIGINT"));
+    process.on("SIGTERM", () => cleanup("SIGTERM"));
+    process.on("SIGHUP", () => cleanup("SIGHUP"));
+
+    // Monitor parent process (opencode) and shutdown if it dies
+    const checkParent = () => {
+      try {
+        process.kill(process.ppid, 0); // Check if parent is alive
+        setTimeout(checkParent, 1000); // Check again in 1 second
+      } catch (error) {
+        // Parent process died, shut down gracefully
+        frameworkLogger.log("mcps/architect-tools", "parent-death", "info");
+        cleanup("parent-process-death");
+      }
+    };
+
+    // Start monitoring parent process
+    setTimeout(checkParent, 2000); // Start checking after 2 seconds
+
+    // Handle uncaught exceptions and unhandled rejections
+    process.on("uncaughtException", (error) => {
+      frameworkLogger.log("mcps/architect-tools", "uncaughtException", "error", { error: String(error) });
+      cleanup("uncaughtException");
+    });
+
+    process.on("unhandledRejection", (reason, promise) => {
+      frameworkLogger.log("mcps/architect-tools", "unhandledRejection", "error", { error: String(reason) });
+      cleanup("unhandledRejection");
+    });
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const server = new StringRayArchitectToolsServer();
+  server.run().catch((error) => frameworkLogger.log("mcps/architect-tools", "run", "error", { error: String(error) }));
+}
+
+export default StringRayArchitectToolsServer;