0xray 4.0.13 → 4.0.14

package/dist/mcps/estimation.server.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Estimation MCP Server
+ *
+ * Provides tools for tracking and validating estimates
+ */
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+/**
+ * Estimation MCP Server
+ * Tracks estimates vs actuals and provides calibrated predictions
+ */
+declare class EstimationServer extends XrayKnowledgeSkillBase {
+    private validator;
+    constructor();
+    private handleValidateEstimate;
+    private handleStartTracking;
+    private handleCompleteTracking;
+    private handleGetReport;
+}
+export { EstimationServer };

package/dist/mcps/estimation.server.js

@@ -0,0 +1,149 @@
+/**
+ * Estimation MCP Server
+ *
+ * Provides tools for tracking and validating estimates
+ */
+import * as fs from "fs";
+import { frameworkLogger } from "../core/framework-logger.js";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+import { getEstimationValidator } from "../validation/estimation-validator.js";
+/**
+ * Estimation MCP Server
+ * Tracks estimates vs actuals and provides calibrated predictions
+ */
+class EstimationServer extends XrayKnowledgeSkillBase {
+    validator = getEstimationValidator();
+    constructor() {
+        super("estimation-validator", "3.1.0");
+        this.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: {},
+                },
+            },
+        ];
+        this.handlers = {
+            "validate-estimate": async (args) => this.handleValidateEstimate(args),
+            "start-tracking": async (args) => this.handleStartTracking(args),
+            "complete-tracking": async (args) => this.handleCompleteTracking(args),
+            "get-accuracy-report": async () => this.handleGetReport(),
+        };
+        this.setupToolHandlers();
+    }
+    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 }] };
+    }
+}
+// Run if called directly
+if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
+    const server = new EstimationServer();
+    server.run().catch((error) => frameworkLogger.log("mcps/estimation", "run", "error", { error: String(error) }));
+}
+export { EstimationServer };

package/dist/mcps/framework-compliance-audit.server.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 0xRay Framework Compliance Audit MCP Server
+ *
+ * Comprehensive validation of all framework components and Universal Development Codex compliance
+ */
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+declare class XrayFrameworkComplianceAuditServer extends XrayKnowledgeSkillBase {
+    constructor();
+    private handleFrameworkComplianceAudit;
+    private handleCodexValidation;
+    private auditConfigurationIntegrity;
+    private auditAgentConfigurations;
+    private auditCodexCompliance;
+    private auditPerformanceThresholds;
+    private validateCodexTerms;
+    private checkTermImplementation;
+    private generateAuditSummary;
+    private getDetailedFindings;
+}
+export { XrayFrameworkComplianceAuditServer };

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

@@ -0,0 +1,471 @@
+/**
+ * 0xRay Framework Compliance Audit MCP Server
+ *
+ * Comprehensive validation of all framework components and Universal Development Codex compliance
+ */
+import fs from "fs";
+import { frameworkLogger } from "../core/framework-logger.js";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+class XrayFrameworkComplianceAuditServer extends XrayKnowledgeSkillBase {
+    constructor() {
+        super("framework-compliance-audit", "3.1.0");
+        this.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",
+                        },
+                    },
+                },
+            },
+        ];
+        this.handlers = {
+            "framework-compliance-audit": async (args) => this.handleFrameworkComplianceAudit(args),
+            "codex-validation": async (args) => this.handleCodexValidation(args),
+        };
+        this.setupToolHandlers();
+        void frameworkLogger.log("framework-compliance-audit.server", "compliance-audit-init", "info", { message: "0xRay Framework Compliance Audit MCP Server initialized" });
+    }
+    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;
+    }
+}
+// Start the server if run directly
+if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
+    const server = new XrayFrameworkComplianceAuditServer();
+    server.run().catch((error) => frameworkLogger.log("mcps/framework-compliance-audit", "run", "error", { error: String(error) }));
+}
+export { XrayFrameworkComplianceAuditServer };

package/dist/mcps/framework-help.server.d.ts

@@ -0,0 +1,13 @@
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+declare class FrameworkHelpServer extends XrayKnowledgeSkillBase {
+    constructor();
+    setupToolHandlers(): void;
+    private getActiveAgentEntries;
+    private handleGetCapabilities;
+    private handleGetCommands;
+    private handleExplainCapability;
+    private generateCommandList;
+    private generateFullCapabilities;
+    private generateCategoryCapabilities;
+}
+export { FrameworkHelpServer };