0xray 4.0.11 → 4.0.13

package/dist/mcps/agent-resolver.js

@@ -1,105 +0,0 @@
-/**
- * Agent Resolver
- *
- * Resolves agent configurations from the 0xRay registry.
- * Used by the integration layer to programmatically access agent configs.
- *
- * @since 2026-02-14
- */
-import * as fs from "fs";
-import * as path from "path";
-import { frameworkLogger } from "../core/framework-logger.js";
-/**
- * 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) {
-    // 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() {
-    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) {
-    // Map agent names to file paths (kebab-case to camelCase for some agents)
-    const agentFileMap = {
-        "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) {
-    return str.replace(/-([a-z])/g, (_g, letter) => letter.toUpperCase());
-}
-/**
- * Gets all available agents from the registry
- */
-export async function getAllAgents() {
-    const registry = await loadAgentRegistry();
-    return Object.keys(registry);
-}
-/**
- * Checks if an agent exists in the registry
- */
-export async function agentExists(agentName) {
-    const registry = await loadAgentRegistry();
-    return agentName in registry;
-}

package/dist/mcps/architect-tools.server.d.ts

@@ -1,16 +0,0 @@
-/**
- * 0xRay Architect Tools MCP Server
- *
- * Converts architect-tools.ts functions into MCP server tools
- * Provides contextual analysis capabilities via MCP protocol
- */
-import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
-declare class XrayArchitectToolsServer extends XrayKnowledgeSkillBase {
-    constructor();
-    setupToolHandlers(): void;
-    private contextAnalysis;
-    private codebaseStructure;
-    private dependencyAnalysis;
-    private architectureAssessment;
-}
-export default XrayArchitectToolsServer;

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

@@ -1,217 +0,0 @@
-/**
- * 0xRay Architect Tools MCP Server
- *
- * Converts architect-tools.ts functions into MCP server tools
- * Provides contextual analysis capabilities via MCP protocol
- */
-import { CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
-import * as fs from "fs";
-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 XrayArchitectToolsServer extends XrayKnowledgeSkillBase {
-    constructor() {
-        super("architect-tools", "3.1.0");
-        this.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.handlers = {
-            "context-analysis": async (args) => this.contextAnalysis(args),
-            "codebase-structure": async (args) => this.codebaseStructure(args),
-            "dependency-analysis": async (args) => this.dependencyAnalysis(args),
-            "architecture-assessment": async (args) => this.architectureAssessment(args),
-        };
-        this.setupToolHandlers();
-        frameworkLogger.log("mcps/architect-tools", "init", "info", { message: "0xRay Architect Tools MCP Server initialized" });
-    }
-    setupToolHandlers() {
-        this.setupListToolsHandler();
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            const handler = this.handlers[name];
-            if (!handler)
-                throw new Error(`Unknown tool: ${name}`);
-            try {
-                return await handler(args);
-            }
-            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";
-        const conferPrompt = typeof args?.conferPrompt === "string" ? args.conferPrompt : "";
-        frameworkLogger.log("mcps/architect-tools", "architecture-assessment", "info", { projectRoot });
-        const result = await architectArchitectureAssessment(projectRoot, assessmentType);
-        const assessmentJson = JSON.stringify(result, null, 2);
-        const text = conferPrompt.trim()
-            ? `${conferPrompt.trim()}\n\n## Architecture assessment\n${assessmentJson}\n\nVerdict: CONDITIONAL\nTop risks: review assessment metrics above\nHardening: address high-complexity or coupling findings before resuming`
-            : assessmentJson;
-        return {
-            content: [
-                {
-                    type: "text",
-                    text,
-                },
-            ],
-        };
-    }
-}
-if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
-    const server = new XrayArchitectToolsServer();
-    server.run().catch((error) => frameworkLogger.log("mcps/architect-tools", "run", "error", { error: String(error) }));
-}
-export default XrayArchitectToolsServer;

package/dist/mcps/auto-format.server.d.ts

@@ -1,18 +0,0 @@
-/**
- * 0xRay Auto Format MCP Server
- *
- * Automated code formatting hook with Prettier and framework-specific formatters
- */
-import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
-declare class XrayAutoFormatServer extends XrayKnowledgeSkillBase {
-    constructor();
-    setupToolHandlers(): void;
-    private handleAutoFormat;
-    private handleFormatCheck;
-    private runPrettier;
-    private runEslintFix;
-    private runTypeScriptFormat;
-    private checkFormatting;
-    private generateFormatSummary;
-}
-export { XrayAutoFormatServer };