0xray 4.0.11 → 4.0.13

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

@@ -1,19 +0,0 @@
-/**
- * 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

@@ -1,149 +0,0 @@
-/**
- * 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

@@ -1,20 +0,0 @@
-/**
- * 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

@@ -1,471 +0,0 @@
-/**
- * 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

@@ -1,13 +0,0 @@
-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 };