0xray 2.0.0

package/dist/mcps/estimation.server.js

@@ -0,0 +1,192 @@
+/**
+ * Estimation MCP Server
+ *
+ * Provides tools for tracking and validating estimates
+ */
+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 { getEstimationValidator } from "../validation/estimation-validator.js";
+/**
+ * Estimation MCP Server
+ * Tracks estimates vs actuals and provides calibrated predictions
+ */
+class EstimationServer {
+    server;
+    validator = getEstimationValidator();
+    constructor() {
+        this.server = new Server({
+            name: "estimation-validator", version: "1.22.67",
+        }, {
+            capabilities: { tools: {} },
+        });
+        this.setupToolHandlers();
+    }
+    setupToolHandlers() {
+        // List available tools
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+            return {
+                tools: [
+                    {
+                        name: "validate-estimate",
+                        description: "Validate an estimate against historical data",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                category: {
+                                    type: "string",
+                                    description: "Task category (e.g., 'refactoring', 'testing', 'documentation')",
+                                },
+                                estimate: {
+                                    type: "number",
+                                    description: "Estimated time in minutes",
+                                },
+                                description: {
+                                    type: "string",
+                                    description: "Brief description of the task",
+                                },
+                            },
+                            required: ["category", "estimate"],
+                        },
+                    },
+                    {
+                        name: "start-tracking",
+                        description: "Start tracking time for a task",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                taskId: { type: "string" },
+                                category: { type: "string" },
+                                estimate: { type: "number" },
+                                description: { type: "string" },
+                            },
+                            required: ["taskId", "category", "estimate"],
+                        },
+                    },
+                    {
+                        name: "complete-tracking",
+                        description: "Complete tracking for a task",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                taskId: { type: "string" },
+                            },
+                            required: ["taskId"],
+                        },
+                    },
+                    {
+                        name: "get-accuracy-report",
+                        description: "Get estimation accuracy report",
+                        inputSchema: {
+                            type: "object",
+                            properties: {},
+                        },
+                    },
+                ],
+            };
+        });
+        // Handle tool calls
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            try {
+                const { name, arguments: args } = request.params;
+                if (args == null) {
+                    throw new Error(`Tool '${name}' called with no arguments`);
+                }
+                switch (name) {
+                    case "validate-estimate":
+                        return this.handleValidateEstimate(args);
+                    case "start-tracking":
+                        return this.handleStartTracking(args);
+                    case "complete-tracking":
+                        return this.handleCompleteTracking(args);
+                    case "get-accuracy-report":
+                        return this.handleGetReport();
+                    default:
+                        throw new Error(`Unknown tool: ${name}`);
+                }
+            }
+            catch (error) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error handling tool '${request.params.name}': ${error instanceof Error ? error.message : String(error)}`,
+                        }],
+                };
+            }
+        });
+    }
+    handleValidateEstimate(args) {
+        const validation = this.validator.validateEstimate(args.category, args.estimate);
+        const calibrated = this.validator.getCalibratedEstimate(args.category, args.estimate);
+        let response = `📊 Estimate Validation: ${args.description || args.category}\n\n`;
+        response += `Your estimate: ${args.estimate} minutes\n`;
+        response += `Calibrated estimate: ${calibrated.calibratedEstimate} minutes (${Math.round(calibrated.calibrationFactor * 100)}% of estimate)\n`;
+        response += `Confidence: ${Math.round(calibrated.confidence * 100)}%\n\n`;
+        if (!validation.isReasonable) {
+            response += `⚠️ ${validation.warning}\n\n`;
+            response += `Suggested: ${validation.suggestedEstimate} minutes\n`;
+        }
+        else if (validation.warning) {
+            response += `ℹ️ ${validation.warning}\n`;
+        }
+        else {
+            response += `✅ Estimate looks reasonable based on historical data.\n`;
+        }
+        return { content: [{ type: "text", text: response }] };
+    }
+    handleStartTracking(args) {
+        this.validator.startEstimate(args.taskId, args.description || args.taskId, args.category, args.estimate);
+        return {
+            content: [{
+                    type: "text",
+                    text: `⏱️ Started tracking "${args.taskId}"\nCategory: ${args.category}\nEstimated: ${args.estimate} minutes`,
+                }],
+        };
+    }
+    handleCompleteTracking(args) {
+        this.validator.completeEstimate(args.taskId);
+        return {
+            content: [{
+                    type: "text",
+                    text: `✅ Completed tracking "${args.taskId}"\nTime recorded and calibration updated.`,
+                }],
+        };
+    }
+    handleGetReport() {
+        const report = this.validator.getAccuracyReport();
+        let response = `📈 Estimation Accuracy Report\n\n`;
+        response += `Overall Accuracy: ${Math.round(report.overallAccuracy * 100)}%\n\n`;
+        if (report.categoryBreakdown.length > 0) {
+            response += `Category Breakdown:\n`;
+            for (const cat of report.categoryBreakdown) {
+                const emoji = cat.trend === 'under' ? '🐌' : cat.trend === 'over' ? '⚡' : '✅';
+                response += `${emoji} ${cat.category}: ${cat.sampleSize} samples, avg ratio ${cat.avgRatio.toFixed(2)}\n`;
+            }
+            response += `\n`;
+        }
+        if (report.recommendations.length > 0) {
+            response += `Recommendations:\n`;
+            for (const rec of report.recommendations) {
+                response += `• ${rec}\n`;
+            }
+        }
+        else {
+            response += `✅ Your estimates are well-calibrated!\n`;
+        }
+        return { content: [{ type: "text", text: response }] };
+    }
+    async start() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        frameworkLogger.log("estimation-server", "start", "info", {
+            message: "Estimation Validator Server started",
+        });
+    }
+}
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const server = new EstimationServer();
+    server.start().catch((error) => frameworkLogger.log("mcps/estimation", "run", "error", { error: String(error) }));
+}
+export { EstimationServer };

package/dist/mcps/framework-compliance-audit.server.js

@@ -0,0 +1,500 @@
+/**
+ * 0xRay Framework Compliance Audit MCP Server
+ *
+ * Comprehensive validation of all framework components and Universal Development Codex compliance
+ */
+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 fs from "fs";
+import { frameworkLogger } from "../core/framework-logger.js";
+class StringRayFrameworkComplianceAuditServer {
+    server;
+    constructor() {
+        this.server = new Server({
+            name: "framework-compliance-audit", version: "1.22.67",
+        }, {
+            capabilities: {
+                tools: {},
+            },
+        });
+        this.setupToolHandlers();
+        void frameworkLogger.log("framework-compliance-audit.server", "compliance-audit-init", "info", { message: "0xRay Framework Compliance Audit MCP Server initialized" });
+    }
+    setupToolHandlers() {
+        // List available tools
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+            return {
+                tools: [
+                    {
+                        name: "framework-compliance-audit",
+                        description: "Comprehensive validation of all framework components and Universal Development Codex compliance",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                scope: {
+                                    type: "string",
+                                    enum: [
+                                        "full",
+                                        "codex",
+                                        "configuration",
+                                        "agents",
+                                        "performance",
+                                    ],
+                                    default: "full",
+                                    description: "Scope of compliance audit",
+                                },
+                                detailed: {
+                                    type: "boolean",
+                                    default: false,
+                                    description: "Include detailed findings and recommendations",
+                                },
+                            },
+                        },
+                    },
+                    {
+                        name: "codex-validation",
+                        description: "Validate compliance with Universal Development Codex v1.2.0",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                terms: {
+                                    type: "array",
+                                    items: { type: "number", minimum: 1, maximum: 43 },
+                                    description: "Specific codex terms to validate (1-43)",
+                                },
+                                strict: {
+                                    type: "boolean",
+                                    default: true,
+                                    description: "Enforce strict compliance",
+                                },
+                            },
+                        },
+                    },
+                ],
+            };
+        });
+        // Handle tool calls
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            switch (name) {
+                case "framework-compliance-audit":
+                    return await this.handleFrameworkComplianceAudit(args);
+                case "codex-validation":
+                    return await this.handleCodexValidation(args);
+                default:
+                    throw new Error(`Unknown tool: ${name}`);
+            }
+        });
+    }
+    async handleFrameworkComplianceAudit(args) {
+        const scope = args.scope || "full";
+        const detailed = args.detailed || false;
+        await frameworkLogger.log("framework-compliance-audit.server", "-mcp-performing-framework-compliance-audit-scope-d", "info", {
+            message: "📋 MCP: Performing framework compliance audit:",
+            scope,
+            detailed: detailed,
+        });
+        const auditResults = {
+            passed: true,
+            criticalIssues: [],
+            warnings: [],
+            complianceScores: {},
+            recommendations: [],
+            summary: "",
+        };
+        try {
+            // 1. Configuration Integrity Check
+            if (scope === "configuration" || scope === "full") {
+                const configResults = await this.auditConfigurationIntegrity();
+                auditResults.criticalIssues.push(...configResults.issues);
+                auditResults.complianceScores.configuration_integrity =
+                    configResults.score;
+                auditResults.recommendations.push(...configResults.recommendations);
+                if (!configResults.passed)
+                    auditResults.passed = false;
+            }
+            // 2. Agent Configuration Audit
+            if (scope === "agents" || scope === "full") {
+                const agentResults = await this.auditAgentConfigurations();
+                auditResults.criticalIssues.push(...agentResults.issues);
+                auditResults.complianceScores.agent_configurations = agentResults.score;
+                auditResults.recommendations.push(...agentResults.recommendations);
+                if (!agentResults.passed)
+                    auditResults.passed = false;
+            }
+            // 3. Codex Compliance Validation
+            if (scope === "codex" || scope === "full") {
+                const codexResults = await this.auditCodexCompliance();
+                auditResults.criticalIssues.push(...codexResults.issues);
+                auditResults.warnings.push(...codexResults.warnings);
+                auditResults.complianceScores.codex_compliance = codexResults.score;
+                auditResults.recommendations.push(...codexResults.recommendations);
+                if (!codexResults.passed)
+                    auditResults.passed = false;
+            }
+            // 4. Performance Thresholds Check
+            if (scope === "performance" || scope === "full") {
+                const perfResults = await this.auditPerformanceThresholds();
+                auditResults.warnings.push(...perfResults.warnings);
+                auditResults.complianceScores.performance_thresholds =
+                    perfResults.score;
+                auditResults.recommendations.push(...perfResults.recommendations);
+                if (!perfResults.passed)
+                    auditResults.passed = false;
+            }
+            // Generate summary
+            auditResults.summary = this.generateAuditSummary(auditResults);
+        }
+        catch (error) {
+            frameworkLogger.log("mcps/framework-compliance-audit", "audit", "error", { error: String(error) });
+            auditResults.passed = false;
+            auditResults.criticalIssues.push(`Audit error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const response = `📋 0xRay Framework Compliance Audit Results
+
+${auditResults.summary}
+
+**Critical Issues:** ${auditResults.criticalIssues.length}
+${auditResults.criticalIssues.length > 0 ? auditResults.criticalIssues.map((issue) => `• ❌ ${issue}`).join("\n") : "None"}
+
+**Warnings:** ${auditResults.warnings.length}
+${auditResults.warnings.length > 0 ? auditResults.warnings.map((warning) => `• ⚠️ ${warning}`).join("\n") : "None"}
+
+**Compliance Scores:**
+${Object.entries(auditResults.complianceScores)
+            .map(([key, value]) => `• ${key}: ${value}`)
+            .join("\n")}
+
+**Recommendations:**
+${auditResults.recommendations.length > 0 ? auditResults.recommendations.map((rec) => `• 💡 ${rec}`).join("\n") : "No recommendations"}
+
+**Overall Status:** ${auditResults.passed ? "✅ COMPLIANT" : "❌ NON-COMPLIANT"}`;
+        if (detailed) {
+            // Add detailed findings
+            const detailedFindings = await this.getDetailedFindings(auditResults);
+            return {
+                content: [
+                    { type: "text", text: response },
+                    {
+                        type: "text",
+                        text: `\n📋 Detailed Findings:\n${detailedFindings}`,
+                    },
+                ],
+            };
+        }
+        return {
+            content: [{ type: "text", text: response }],
+        };
+    }
+    async handleCodexValidation(args) {
+        const terms = args.terms || [];
+        const strict = args.strict !== false;
+        await frameworkLogger.log("framework-compliance-audit.server", "-mcp-performing-codex-validation-terms-terms-lengt", "info", {
+            message: "📚 MCP: Performing codex validation:",
+            terms: terms.length,
+            strict: strict,
+        });
+        try {
+            const results = await this.validateCodexTerms(terms, strict);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `📚 Codex Validation Results
+
+**Terms Validated:** ${results.validatedCount}/${results.totalTerms}
+**Compliance:** ${results.compliancePercentage}%
+
+**Violations:** ${results.violations.length}
+${results.violations.length > 0 ? results.violations.map((v) => `• ❌ ${v}`).join("\n") : "None"}
+
+**Recommendations:**
+${results.recommendations.map((r) => `• 💡 ${r}`).join("\n")}
+
+**Status:** ${results.passed ? "✅ COMPLIANT" : "❌ VIOLATIONS DETECTED"}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ Codex validation failed: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    }
+    async auditConfigurationIntegrity() {
+        const results = {
+            passed: true,
+            issues: [],
+            score: "PASS",
+            recommendations: [],
+        };
+        try {
+            // Check for required configuration files
+            const requiredFiles = [
+                "src/agents/types.ts",
+            ];
+            let presentCount = 0;
+            for (const file of requiredFiles) {
+                if (fs.existsSync(file)) {
+                    presentCount++;
+                }
+                else {
+                    results.issues.push(`Missing configuration file: ${file}`);
+                    results.recommendations.push(`Create ${file} with proper framework configuration`);
+                }
+            }
+            const percentage = Math.round((presentCount / requiredFiles.length) * 100);
+            results.score = `${percentage}% (${presentCount}/${requiredFiles.length})`;
+            if (percentage < 100) {
+                results.passed = false;
+                results.score = `FAIL: ${results.score}`;
+            }
+        }
+        catch (error) {
+            results.passed = false;
+            results.issues.push(`Configuration audit error: ${error instanceof Error ? error.message : String(error)}`);
+            results.score = "ERROR";
+        }
+        return results;
+    }
+    async auditAgentConfigurations() {
+        const results = {
+            passed: true,
+            issues: [],
+            score: "0%",
+            recommendations: [],
+        };
+        try {
+            const requiredAgents = [
+                "architect",
+                "bug-triage-specialist",
+                "code-reviewer",
+                "security-auditor",
+                "refactorer",
+                "testing-lead",
+                "log-monitor",
+            ];
+            let presentCount = 0;
+            for (const agent of requiredAgents) {
+                const agentFile = `src/agents/${agent}.ts`;
+                if (fs.existsSync(agentFile)) {
+                    presentCount++;
+                }
+                else {
+                    results.issues.push(`Missing agent configuration: ${agent}`);
+                    results.recommendations.push(`Create agent configuration for ${agent}`);
+                }
+            }
+            const percentage = Math.round((presentCount / requiredAgents.length) * 100);
+            results.score = `${percentage}% (${presentCount}/${requiredAgents.length})`;
+            if (percentage < 80) {
+                // Allow some flexibility
+                results.passed = false;
+            }
+        }
+        catch (error) {
+            results.passed = false;
+            results.issues.push(`Agent audit error: ${error instanceof Error ? error.message : String(error)}`);
+            results.score = "ERROR";
+        }
+        return results;
+    }
+    async auditCodexCompliance() {
+        const results = {
+            passed: true,
+            issues: [],
+            warnings: [],
+            score: "0%",
+            recommendations: [],
+        };
+        try {
+            // Check if codex terms are referenced in agent configurations
+            const agentFiles = [
+                "src/agents/architect.ts",
+                "src/agents/code-reviewer.ts",
+                "src/agents/refactorer.ts",
+            ];
+            let totalTerms = 0;
+            let validatedTerms = 0;
+            for (const file of agentFiles) {
+                if (fs.existsSync(file)) {
+                    const content = fs.readFileSync(file, "utf8");
+                    // Check for codex term references
+                    const codexPatterns = [
+                        /codex/i,
+                        /Universal Development Codex/i,
+                        /55-terms/i,
+                        /error prevention/i,
+                        /zero-tolerance/i,
+                    ];
+                    let fileValidated = 0;
+                    for (const pattern of codexPatterns) {
+                        if (pattern.test(content)) {
+                            fileValidated++;
+                        }
+                    }
+                    validatedTerms += fileValidated;
+                    totalTerms += codexPatterns.length;
+                }
+            }
+            const percentage = totalTerms > 0 ? Math.round((validatedTerms / totalTerms) * 100) : 0;
+            results.score = `${percentage}%`;
+            if (percentage < 70) {
+                results.passed = false;
+                results.issues.push("Low codex compliance in agent configurations");
+                results.recommendations.push("Enhance agent configurations with codex term references");
+            }
+            // Check for codex validation files
+            void "codex_loader check removed (Python file does not exist)";
+        }
+        catch (error) {
+            results.passed = false;
+            results.issues.push(`Codex audit error: ${error instanceof Error ? error.message : String(error)}`);
+            results.score = "ERROR";
+        }
+        return results;
+    }
+    async auditPerformanceThresholds() {
+        const results = {
+            passed: true,
+            warnings: [],
+            score: "PASS",
+            recommendations: [],
+        };
+        try {
+            // Check bundle size (if build exists)
+            if (fs.existsSync("dist")) {
+                const { execSync } = await import("child_process");
+                try {
+                    const sizeOutput = execSync('du -sh dist/ 2>/dev/null || echo "0"', {
+                        encoding: "utf8",
+                    });
+                    const size = sizeOutput.trim().split("	")[0] || "0";
+                    // Check against 2MB threshold
+                    if (size.includes("M") && parseFloat(size) > 2.0) {
+                        results.warnings.push(`Bundle size ${size} exceeds 2MB threshold`);
+                        results.recommendations.push("Optimize bundle size through code splitting and tree shaking");
+                        results.passed = false;
+                    }
+                }
+                catch (error) {
+                    // Size check failed
+                }
+            }
+            // Check for performance monitoring
+            void "performance monitor check removed (Python file does not exist)";
+        }
+        catch (error) {
+            results.warnings.push(`Performance audit error: ${error instanceof Error ? error.message : String(error)}`);
+            results.score = "WARNING";
+        }
+        return results;
+    }
+    async validateCodexTerms(specificTerms, strict) {
+        const results = {
+            validatedCount: 0,
+            totalTerms: 43,
+            compliancePercentage: 0,
+            violations: [],
+            recommendations: [],
+            passed: true,
+        };
+        try {
+            const termsToValidate = specificTerms.length > 0
+                ? specificTerms
+                : Array.from({ length: 43 }, (_, i) => i + 1);
+            // Read agent configurations to check for term implementations
+            const agentFiles = [
+                "src/agents/architect.ts",
+                "src/agents/code-reviewer.ts",
+                "src/agents/refactorer.ts",
+            ];
+            for (const term of termsToValidate) {
+                let termValidated = false;
+                // Check each agent file for term implementation
+                for (const file of agentFiles) {
+                    if (fs.existsSync(file)) {
+                        const content = fs.readFileSync(file, "utf8");
+                        if (this.checkTermImplementation(term, content)) {
+                            termValidated = true;
+                            break;
+                        }
+                    }
+                }
+                if (termValidated) {
+                    results.validatedCount++;
+                }
+                else if (strict) {
+                    results.violations.push(`Codex term ${term} not implemented`);
+                    results.passed = false;
+                }
+            }
+            results.compliancePercentage = Math.round((results.validatedCount / termsToValidate.length) * 100);
+            if (results.violations.length > 0) {
+                results.recommendations.push("Implement missing codex terms in agent configurations");
+            }
+        }
+        catch (error) {
+            results.passed = false;
+            results.violations.push(`Codex validation error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return results;
+    }
+    checkTermImplementation(term, content) {
+        // Simplified term checking - in a real implementation this would be more sophisticated
+        const termPatterns = {
+            1: [/progressive.*ready/i, /production.*ready/i],
+            2: [/no.*stubs/i, /no.*patches/i],
+            3: [/over.*engineer/i, /minimal.*complexity/i],
+            4: [/fit.*purpose/i, /production.*level/i],
+            5: [/surgical.*fixes/i],
+            7: [/resolve.*errors/i, /error.*prevention/i],
+            8: [/prevent.*loops/i, /infinite.*loops/i],
+            12: [/type.*safety/i],
+            26: [/test.*coverage.*85/i],
+            43: [/infrastructure.*code.*validation/i],
+        };
+        const patterns = termPatterns[term] || [];
+        return patterns.some((pattern) => pattern.test(content));
+    }
+    generateAuditSummary(results) {
+        const status = results.passed ? "✅ COMPLIANT" : "❌ NON-COMPLIANT";
+        const criticalCount = results.criticalIssues.length;
+        const warningCount = results.warnings.length;
+        return `**Audit Summary:** ${status}
+- Critical Issues: ${criticalCount}
+- Warnings: ${warningCount}
+- Compliance Areas: ${Object.keys(results.complianceScores).length}`;
+    }
+    async getDetailedFindings(results) {
+        // Generate detailed findings report
+        let details = "## Detailed Compliance Findings\n\n";
+        details += "### Configuration Integrity\n";
+        details += `- Status: ${results.complianceScores.configuration_integrity || "Not checked"}\n\n`;
+        details += "### Agent Configurations\n";
+        details += `- Status: ${results.complianceScores.agent_configurations || "Not checked"}\n\n`;
+        details += "### Codex Compliance\n";
+        details += `- Status: ${results.complianceScores.codex_compliance || "Not checked"}\n\n`;
+        details += "### Performance Thresholds\n";
+        details += `- Status: ${results.complianceScores.performance_thresholds || "Not checked"}\n\n`;
+        return details;
+    }
+    async run() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        void frameworkLogger.log("framework-compliance-audit.server", "compliance-audit-startup", "info", { message: "0xRay Framework Compliance Audit MCP Server started" });
+    }
+}
+// Start the server if run directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const server = new StringRayFrameworkComplianceAuditServer();
+    server.run().catch((error) => frameworkLogger.log("mcps/framework-compliance-audit", "run", "error", { error: String(error) }));
+}
+export { StringRayFrameworkComplianceAuditServer };