0xray 2.0.0

package/dist/mcps/architect-tools.server.js

@@ -0,0 +1,277 @@
+/**
+ * 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, } from "@modelcontextprotocol/sdk/types.js";
+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";
+class StringRayArchitectToolsServer {
+    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" });
+    }
+    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) => {
+            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
+    async contextAnalysis(args) {
+        const projectRoot = args?.projectRoot || "";
+        const depth = args?.depth || "detailed";
+        const includeFiles = args?.includeFiles;
+        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),
+                },
+            ],
+        };
+    }
+    async codebaseStructure(args) {
+        const projectRoot = args?.projectRoot || "";
+        const includeMetrics = args?.includeMetrics ?? 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),
+                },
+            ],
+        };
+    }
+    async dependencyAnalysis(args) {
+        const projectRoot = args?.projectRoot || "";
+        const focusAreas = args?.focusAreas;
+        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),
+                },
+            ],
+        };
+    }
+    async architectureAssessment(args) {
+        const projectRoot = args?.projectRoot || "";
+        const assessmentType = args?.assessmentType || "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() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        frameworkLogger.log("mcps/architect-tools", "start", "info");
+        const cleanup = async (signal) => {
+            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;

package/dist/mcps/auto-format.server.js

@@ -0,0 +1,413 @@
+/**
+ * 0xRay Auto Format MCP Server
+ *
+ * Automated code formatting hook with Prettier and framework-specific formatters
+ */
+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";
+class StringRayAutoFormatServer {
+    server;
+    constructor() {
+        this.server = new Server({
+            name: "auto-format", version: "1.22.67",
+        }, {
+            capabilities: {
+                tools: {},
+            },
+        });
+        this.setupToolHandlers();
+        frameworkLogger.log("mcps/auto-format", "initialize", "info");
+    }
+    setupToolHandlers() {
+        // List available tools
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+            return {
+                tools: [
+                    {
+                        name: "auto-format",
+                        description: "Automated code formatting hook with Prettier and framework-specific formatters",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                files: {
+                                    type: "array",
+                                    items: { type: "string" },
+                                    description: "Specific files to format (optional - formats all if empty)",
+                                },
+                                formatters: {
+                                    type: "array",
+                                    items: {
+                                        type: "string",
+                                        enum: ["prettier", "eslint", "typescript", "all"],
+                                    },
+                                    default: ["all"],
+                                    description: "Formatters to apply",
+                                },
+                                checkOnly: {
+                                    type: "boolean",
+                                    default: false,
+                                    description: "Only check formatting without applying changes",
+                                },
+                            },
+                        },
+                    },
+                    {
+                        name: "format-check",
+                        description: "Check if code is properly formatted without making changes",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                files: {
+                                    type: "array",
+                                    items: { type: "string" },
+                                    description: "Files to check formatting for",
+                                },
+                            },
+                        },
+                    },
+                ],
+            };
+        });
+        // Handle tool calls
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            try {
+                switch (name) {
+                    case "auto-format":
+                        return await this.handleAutoFormat(args);
+                    case "format-check":
+                        return await this.handleFormatCheck(args);
+                    default:
+                        throw new Error(`Unknown tool: ${name}`);
+                }
+            }
+            catch (error) {
+                frameworkLogger.log("mcps/auto-format", "tool-call", "error", {
+                    tool: name,
+                    error: String(error),
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error executing tool '${name}': ${error instanceof Error ? error.message : String(error)}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        });
+    }
+    async handleAutoFormat(args) {
+        const files = args.files || [];
+        const formatters = args.formatters || ["all"];
+        const checkOnly = args.checkOnly || false;
+        frameworkLogger.log("mcps/auto-format", "format", "info", {
+            files: files.length,
+            formatters,
+            checkOnly,
+        });
+        const formatResults = {
+            success: true,
+            formattedFiles: [],
+            errors: [],
+            summary: "",
+            changes: {},
+        };
+        try {
+            // Determine which formatters to run
+            const runPrettier = formatters.includes("all") || formatters.includes("prettier");
+            const runEslint = formatters.includes("all") || formatters.includes("eslint");
+            const runTypescript = formatters.includes("all") || formatters.includes("typescript");
+            // Run Prettier formatting
+            if (runPrettier) {
+                const prettierResults = await this.runPrettier(files, checkOnly);
+                formatResults.formattedFiles.push(...prettierResults.formatted);
+                if (prettierResults.errors.length > 0) {
+                    formatResults.errors.push(...prettierResults.errors);
+                }
+                formatResults.changes.prettier = prettierResults.formatted;
+            }
+            // Run ESLint auto-fix
+            if (runEslint && !checkOnly) {
+                const eslintResults = await this.runEslintFix(files);
+                formatResults.formattedFiles.push(...eslintResults.formatted);
+                if (eslintResults.errors.length > 0) {
+                    formatResults.errors.push(...eslintResults.errors);
+                }
+                formatResults.changes.eslint = eslintResults.formatted;
+            }
+            // Run TypeScript formatting/check
+            if (runTypescript) {
+                const tsResults = await this.runTypeScriptFormat(files, checkOnly);
+                if (tsResults.errors.length > 0) {
+                    formatResults.errors.push(...tsResults.errors);
+                }
+                formatResults.changes.typescript =
+                    tsResults.errors.length === 0
+                        ? ["TypeScript compilation successful"]
+                        : tsResults.errors;
+            }
+            // Check for overall success
+            formatResults.success = formatResults.errors.length === 0;
+            // Generate summary
+            formatResults.summary = this.generateFormatSummary(formatResults);
+        }
+        catch (error) {
+            frameworkLogger.log("mcps/auto-format", "format", "error", { error: String(error) });
+            formatResults.success = false;
+            formatResults.errors.push(`Auto-format failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const response = `🎨 0xRay Auto Format Results
+
+${formatResults.summary}
+
+**Files Formatted:** ${formatResults.formattedFiles.length}
+${formatResults.formattedFiles.length > 0 ? formatResults.formattedFiles.map((f) => `• ${f}`).join("\n") : "None"}
+
+**Errors:** ${formatResults.errors.length}
+${formatResults.errors.length > 0 ? formatResults.errors.map((e) => `• ❌ ${e}`).join("\n") : "None"}
+
+**Formatter Results:**
+${Object.entries(formatResults.changes)
+            .map(([formatter, results]) => `• ${formatter}: ${results.length} files processed`)
+            .join("\n")}
+
+**Status:** ${formatResults.success ? "✅ FORMATTING COMPLETED" : "❌ FORMATTING ISSUES DETECTED"}`;
+        return {
+            content: [{ type: "text", text: response }],
+        };
+    }
+    async handleFormatCheck(args) {
+        const files = args.files || [];
+        frameworkLogger.log("mcps/auto-format", "check", "info", { files: files.length });
+        try {
+            const checkResults = await this.checkFormatting(files);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `🔍 Format Check Results
+
+**Files Checked:** ${files.length}
+**Properly Formatted:** ${checkResults.formatted}
+**Needs Formatting:** ${checkResults.needsFormatting}
+
+**Details:**
+${checkResults.details.map((d) => `• ${d}`).join("\n")}
+
+**Status:** ${checkResults.needsFormatting === 0 ? "✅ ALL FILES FORMATTED" : "⚠️ FORMATTING ISSUES DETECTED"}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ Format check failed: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    }
+    async runPrettier(files, checkOnly) {
+        const results = {
+            formatted: [],
+            errors: [],
+        };
+        try {
+            // Determine file patterns
+            const patterns = files.length > 0 ? files : ["**/*.{js,jsx,ts,tsx,json,css,scss,md}"];
+            // Run prettier
+            const prettierArgs = checkOnly
+                ? ["prettier", "--check", ...patterns, "--ignore-path", ".gitignore"]
+                : ["prettier", "--write", ...patterns, "--ignore-path", ".gitignore"];
+            try {
+                const output = execFileSync("npx", prettierArgs, {
+                    encoding: "utf8",
+                    cwd: process.cwd(),
+                    stdio: "pipe",
+                    timeout: 30000,
+                });
+                if (checkOnly) {
+                    // Parse check output to see what needs formatting
+                    const lines = output
+                        .split("\n")
+                        .filter((line) => line.trim());
+                    results.formatted = lines.filter((line) => !line.includes("error") && !line.includes("Error"));
+                }
+                else {
+                    // Parse write output to get actual file names
+                    const lines = output
+                        .split("\n")
+                        .filter((line) => line.trim());
+                    results.formatted = lines;
+                }
+            }
+            catch (error) {
+                const errorOutput = error instanceof Error
+                    ? error.stdout?.toString() || error.message
+                    : String(error);
+                if (checkOnly && errorOutput.includes("error")) {
+                    // Some files need formatting
+                    results.errors.push("Some files need formatting");
+                }
+                else {
+                    results.errors.push(`Prettier error: ${errorOutput}`);
+                }
+            }
+        }
+        catch (error) {
+            results.errors.push(`Prettier setup error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return results;
+    }
+    async runEslintFix(files) {
+        const results = {
+            formatted: [],
+            errors: [],
+        };
+        try {
+            if (!fs.existsSync("package.json")) {
+                results.errors.push("No package.json found - cannot run ESLint");
+                return results;
+            }
+            // Check if ESLint script exists
+            const packageJson = JSON.parse(fs.readFileSync("package.json", "utf8"));
+            const scripts = packageJson.scripts || {};
+            if (!scripts["lint:fix"] && !scripts.lint) {
+                results.errors.push("No ESLint scripts found in package.json");
+                return results;
+            }
+            const scriptName = scripts["lint:fix"] ? "lint:fix" : "lint";
+            try {
+                execFileSync("npm", ["run", scriptName], {
+                    encoding: "utf8",
+                    cwd: process.cwd(),
+                    stdio: "pipe",
+                    timeout: 30000,
+                });
+                results.formatted.push("ESLint auto-fix applied to applicable files");
+            }
+            catch (error) {
+                const errorOutput = error instanceof Error
+                    ? error.stdout?.toString() || error.message
+                    : String(error);
+                results.errors.push(`ESLint error: ${errorOutput}`);
+            }
+        }
+        catch (error) {
+            results.errors.push(`ESLint setup error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return results;
+    }
+    async runTypeScriptFormat(files, checkOnly) {
+        const results = {
+            formatted: [],
+            errors: [],
+        };
+        try {
+            if (!fs.existsSync("package.json")) {
+                results.errors.push("No package.json found - cannot check TypeScript");
+                return results;
+            }
+            const packageJson = JSON.parse(fs.readFileSync("package.json", "utf8"));
+            const scripts = packageJson.scripts || {};
+            if (!scripts.typecheck && !scripts["type-check"]) {
+                results.errors.push("No TypeScript check scripts found");
+                return results;
+            }
+            const scriptName = scripts.typecheck ? "typecheck" : "type-check";
+            try {
+                execFileSync("npm", ["run", scriptName], {
+                    encoding: "utf8",
+                    cwd: process.cwd(),
+                    stdio: "pipe",
+                    timeout: 30000,
+                });
+                results.formatted.push("TypeScript compilation successful");
+            }
+            catch (error) {
+                const errorOutput = error instanceof Error
+                    ? error.stdout?.toString() || error.message
+                    : String(error);
+                results.errors.push(`TypeScript compilation errors: ${errorOutput.split("\n").slice(0, 3).join("; ")}`);
+            }
+        }
+        catch (error) {
+            results.errors.push(`TypeScript check error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return results;
+    }
+    async checkFormatting(files) {
+        const results = {
+            formatted: 0,
+            needsFormatting: 0,
+            details: [],
+        };
+        try {
+            // Use prettier check
+            const patterns = files.length > 0 ? files : ["**/*.{js,jsx,ts,tsx,json,css,scss,md}"];
+            try {
+                execFileSync("npx", ["prettier", "--check", ...patterns, "--ignore-path", ".gitignore"], {
+                    encoding: "utf8",
+                    cwd: process.cwd(),
+                    stdio: "pipe",
+                    timeout: 30000,
+                });
+                results.formatted = files.length > 0 ? files.length : patterns.length;
+                results.details.push("All checked files are properly formatted");
+            }
+            catch (error) {
+                const errorOutput = error instanceof Error
+                    ? error.stdout?.toString() || error.message
+                    : String(error);
+                // Parse which files need formatting
+                const lines = errorOutput
+                    .split("\n")
+                    .filter((line) => line.trim());
+                const filesNeedingFormat = lines.filter((line) => !line.includes("error") &&
+                    !line.includes("Error") &&
+                    !line.includes("[") &&
+                    line.includes("."));
+                results.needsFormatting = filesNeedingFormat.length;
+                results.formatted = Math.max(0, (files.length > 0 ? files.length : patterns.length) -
+                    results.needsFormatting);
+                results.details.push(`${results.needsFormatting} files need formatting`);
+                if (filesNeedingFormat.length > 0) {
+                    results.details.push(`Files: ${filesNeedingFormat.slice(0, 5).join(", ")}${filesNeedingFormat.length > 5 ? "..." : ""}`);
+                }
+            }
+        }
+        catch (error) {
+            results.details.push(`Format check error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return results;
+    }
+    generateFormatSummary(results) {
+        const totalFiles = results.formattedFiles.length;
+        const errorCount = results.errors.length;
+        const status = results.success ? "COMPLETED" : "ISSUES DETECTED";
+        return `**Formatting Summary:** ${status}
+- Files Processed: ${totalFiles}
+- Errors: ${errorCount}
+- Formatters Applied: ${Object.keys(results.changes).length}`;
+    }
+    async run() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        frameworkLogger.log("mcps/auto-format", "start", "info");
+    }
+}
+// Start the server if run directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const server = new StringRayAutoFormatServer();
+    server.run().catch((error) => frameworkLogger.log("mcps/auto-format", "run", "error", { error: String(error) }));
+}
+export { StringRayAutoFormatServer };