0xray 4.0.12 → 4.0.13

package/dist/mcps/processor-pipeline.server.js

@@ -1,531 +0,0 @@
-/**
- * 0xRay Processor Pipeline MCP Server
- *
- * Advanced processor pipeline with codex validation, compliance monitoring, and framework enforcement
- */
-import * as fs from "fs";
-import { frameworkLogger } from "../core/framework-logger.js";
-import { CodexLoader } from "../enforcement/loaders/codex-loader.js";
-import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
-class XrayProcessorPipelineServer extends XrayKnowledgeSkillBase {
-    codexLoader;
-    codexRules = [];
-    codexTerms = [
-        "Progressive Prod-Ready Code",
-        "No Stubs/Patches",
-        "Surgical Fixes",
-        "Type Safety First",
-        "Single Source of Truth",
-        "Error Boundaries",
-        "Performance Budget Enforcement",
-        "Security by Design",
-        "Test Coverage >85%",
-    ];
-    constructor() {
-        super("processor-pipeline", "3.1.0");
-        this.codexLoader = new CodexLoader();
-        this.tools = [
-            {
-                name: "execute-pre-processors",
-                description: "Run pre-execution processors on content with codex validation",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        content: { type: "string" },
-                        context: { type: "object" },
-                        validateCodex: { type: "boolean", default: true },
-                        strictMode: { type: "boolean", default: false },
-                    },
-                    required: ["content"],
-                },
-            },
-            {
-                name: "execute-post-processors",
-                description: "Run post-execution processors on results with compliance monitoring",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        content: { type: "string" },
-                        results: { type: "object" },
-                        enforceCompliance: { type: "boolean", default: true },
-                        auditTrail: { type: "boolean", default: true },
-                    },
-                    required: ["content"],
-                },
-            },
-            {
-                name: "codex-validation",
-                description: "Validate content against Universal Development Codex terms",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        content: { type: "string" },
-                        terms: {
-                            type: "array",
-                            items: { type: "string" },
-                            default: ["all"],
-                        },
-                        strict: { type: "boolean", default: false },
-                    },
-                    required: ["content"],
-                },
-            },
-            {
-                name: "framework-compliance-check",
-                description: "Check framework compliance and generate enforcement actions",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        content: { type: "string" },
-                        operation: { type: "string" },
-                        context: { type: "object" },
-                    },
-                    required: ["content", "operation"],
-                },
-            },
-        ];
-        this.handlers = {
-            "execute-pre-processors": async (args) => this.handlePreProcessors(args),
-            "execute-post-processors": async (args) => this.handlePostProcessors(args),
-            "codex-validation": async (args) => this.handleCodexValidation(args),
-            "framework-compliance-check": async (args) => this.handleComplianceCheck(args),
-        };
-        this.setupToolHandlers();
-        this.loadCodexRules();
-        // Server initialized silently - use frameworkLogger for important events
-    }
-    async loadCodexRules() {
-        try {
-            if (await this.codexLoader.isAvailable()) {
-                this.codexRules = await this.codexLoader.load();
-                await frameworkLogger.log("mcps/processor-pipeline", "codex-rules-loaded", "success", { message: `Loaded ${this.codexRules.length} codex rules for MCP validation` });
-            }
-        }
-        catch (error) {
-            await frameworkLogger.log("mcps/processor-pipeline", "codex-rules-load-failed", "warning", { message: `Failed to load codex rules: ${error instanceof Error ? error.message : String(error)}` });
-        }
-    }
-    async handlePreProcessors(args) {
-        const content = args.content;
-        const context = args.context || {};
-        const validateCodex = args.validateCodex !== false;
-        const strictMode = args.strictMode || false;
-        // Silent execution - no console output
-        const results = {
-            processed: content,
-            validations: [],
-            warnings: [],
-            blocked: false,
-            reason: "",
-        };
-        try {
-            // 1. Input sanitization
-            results.processed = this.sanitizeInput(content);
-            // 2. Codex validation (if enabled)
-            if (validateCodex) {
-                const codexResults = await this.validateAgainstCodex(results.processed, strictMode);
-                results.validations.push(...codexResults.validations);
-                results.warnings.push(...codexResults.warnings);
-                if (codexResults.blocked) {
-                    results.blocked = true;
-                    results.reason = codexResults.reason;
-                }
-            }
-            // 3. Context enrichment
-            results.processed = this.enrichWithContext(results.processed, context);
-            // 4. Security checks
-            const securityResults = this.performSecurityChecks(results.processed);
-            results.warnings.push(...securityResults.warnings);
-        }
-        catch (error) {
-            results.blocked = true;
-            results.reason = `Pre-processing error: ${error instanceof Error ? error.message : String(error)}`;
-        }
-        const response = `🔄 Pre-Processor Results
-
-**Content Length:** ${results.processed.length} characters
-**Validations Passed:** ${results.validations.length}
-**Warnings:** ${results.warnings.length}
-${results.warnings.length > 0 ? results.warnings.map((w) => `• ⚠️ ${w}`).join("\n") : ""}
-
-**Status:** ${results.blocked ? `❌ BLOCKED - ${results.reason}` : "✅ APPROVED FOR EXECUTION"}`;
-        return {
-            content: [{ type: "text", text: response }],
-        };
-    }
-    async handlePostProcessors(args) {
-        const content = args.content;
-        const results = args.results || {};
-        const enforceCompliance = args.enforceCompliance !== false;
-        const auditTrail = args.auditTrail !== false;
-        // Silent execution - no console output
-        const postResults = {
-            processed: content,
-            compliance: [],
-            auditEntries: [],
-            recommendations: [],
-            finalApproval: true,
-        };
-        try {
-            // 1. Result validation
-            postResults.processed = this.validateResults(content, results);
-            // 2. Compliance enforcement
-            if (enforceCompliance) {
-                const complianceResults = await this.enforceCompliance(postResults.processed);
-                postResults.compliance.push(...complianceResults.compliance);
-                postResults.recommendations.push(...complianceResults.recommendations);
-                if (!complianceResults.approved) {
-                    postResults.finalApproval = false;
-                }
-            }
-            // 3. Audit trail generation
-            if (auditTrail) {
-                postResults.auditEntries = this.generateAuditTrail(content, results, postResults);
-            }
-            // 4. Quality assurance
-            const qaResults = this.performQualityAssurance(postResults.processed);
-            postResults.recommendations.push(...qaResults.recommendations);
-        }
-        catch (error) {
-            postResults.finalApproval = false;
-            postResults.recommendations.push(`Post-processing error: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        const response = `🔄 Post-Processor Results
-
-**Final Approval:** ${postResults.finalApproval ? "✅ APPROVED" : "❌ REQUIRES REVIEW"}
-**Compliance Checks:** ${postResults.compliance.length}
-**Audit Entries:** ${postResults.auditEntries.length}
-**Recommendations:** ${postResults.recommendations.length}
-
-**Recommendations:**
-${postResults.recommendations.length > 0 ? postResults.recommendations.map((r) => `• 💡 ${r}`).join("\n") : "None"}
-
-**Audit Summary:**
-${postResults.auditEntries
-            .slice(0, 3)
-            .map((a) => `• 📝 ${a}`)
-            .join("\n")}${postResults.auditEntries.length > 3 ? "\n• ..." : ""}`;
-        return {
-            content: [{ type: "text", text: response }],
-        };
-    }
-    async handleCodexValidation(args) {
-        const content = args.content;
-        const terms = args.terms || ["all"];
-        const strict = args.strict || false;
-        // Silent validation - no console output
-        try {
-            const validationResults = await this.validateAgainstCodex(content, strict, terms);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `📚 Codex Validation Results
-
-**Content Validated:** ${content.length} characters
-**Terms Checked:** ${terms.length === 1 && terms[0] === "all" ? "All 55-terms" : terms.length}
-**Compliance:** ${validationResults.compliance}%
-
-**Violations:** ${validationResults.violations.length}
-${validationResults.violations.map((v) => `• ❌ ${v}`).join("\n") || "None"}
-
-**Warnings:** ${validationResults.warnings.length}
-${validationResults.warnings.map((w) => `• ⚠️ ${w}`).join("\n") || "None"}
-
-**Recommendations:**
-${validationResults.recommendations.map((r) => `• 💡 ${r}`).join("\n") || "None"}
-
-**Status:** ${validationResults.blocked ? "❌ BLOCKED" : "✅ COMPLIANT"}`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `❌ Codex validation failed: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-            };
-        }
-    }
-    async handleComplianceCheck(args) {
-        const content = args.content;
-        const operation = args.operation;
-        const context = args.context || {};
-        // Silent compliance check - no console output
-        try {
-            const complianceResults = await this.checkFrameworkCompliance(content, operation, context);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `📋 Framework Compliance Check
-
-**Operation:** ${operation}
-**Content Type:** ${this.detectContentType(content)}
-
-**Compliance Score:** ${complianceResults.score}/100
-**Critical Issues:** ${complianceResults.criticalIssues.length}
-**Warnings:** ${complianceResults.warnings.length}
-
-**Critical Issues:**
-${complianceResults.criticalIssues.map((i) => `• ❌ ${i}`).join("\n") || "None"}
-
-**Warnings:**
-${complianceResults.warnings.map((w) => `• ⚠️ ${w}`).join("\n") || "None"}
-
-**Enforcement Actions:**
-${complianceResults.actions.map((a) => `• 🔧 ${a}`).join("\n") || "None required"}
-
-**Status:** ${complianceResults.approved ? "✅ COMPLIANT" : "❌ REQUIRES CORRECTION"}`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `❌ Compliance check failed: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-            };
-        }
-    }
-    sanitizeInput(content) {
-        // Basic input sanitization
-        return content
-            .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "[SCRIPT REMOVED]")
-            .replace(/javascript:/gi, "[JAVASCRIPT REMOVED]")
-            .trim();
-    }
-    async validateAgainstCodex(content, strict, terms) {
-        const results = {
-            validations: [],
-            warnings: [],
-            violations: [],
-            recommendations: [],
-            compliance: 0,
-            blocked: false,
-            reason: "",
-        };
-        // Use loaded codex rules if available, otherwise fall back to hardcoded terms
-        if (this.codexRules.length > 0) {
-            const termsToCheck = terms && terms.length > 0 && !terms.includes("all")
-                ? terms
-                : this.codexRules.map(r => r.name);
-            let passed = 0;
-            for (const rule of this.codexRules) {
-                // Filter by requested terms if specified
-                if (terms && terms.length > 0 && !terms.includes("all") && !terms.includes(rule.name)) {
-                    continue;
-                }
-                try {
-                    const context = {
-                        newCode: content,
-                        operation: "write",
-                        files: []
-                    };
-                    const validationResult = await rule.validator(context);
-                    if (validationResult.passed) {
-                        passed++;
-                        results.validations.push(`${rule.name}: PASS`);
-                    }
-                    else {
-                        results.violations.push(`${rule.name}: ${validationResult.message}`);
-                        results.recommendations.push(...(validationResult.suggestions || []));
-                        const isBlocking = rule.severity === "blocking" || rule.severity === "error";
-                        if (strict || isBlocking) {
-                            results.blocked = true;
-                            results.reason = `Codex violation: ${rule.name}`;
-                        }
-                    }
-                }
-                catch (err) {
-                    results.warnings.push(`${rule.name}: Validation error - ${err instanceof Error ? err.message : String(err)}`);
-                }
-            }
-            results.compliance = termsToCheck.length > 0
-                ? Math.round((passed / termsToCheck.length) * 100)
-                : 100;
-            return results;
-        }
-        // Fallback to hardcoded term checking (legacy behavior)
-        const termsToCheck = terms && terms.length > 0 && !terms.includes("all")
-            ? terms
-            : this.codexTerms;
-        let passed = 0;
-        for (const term of termsToCheck) {
-            const termResult = this.checkCodexTerm(content, term);
-            if (termResult.passed) {
-                passed++;
-                results.validations.push(`${term}: PASS`);
-            }
-            else {
-                results.violations.push(`${term}: ${termResult.reason}`);
-                results.recommendations.push(termResult.recommendation);
-                if (strict || termResult.critical) {
-                    results.blocked = true;
-                    results.reason = `Codex violation: ${term}`;
-                }
-            }
-        }
-        results.compliance = Math.round((passed / termsToCheck.length) * 100);
-        return results;
-    }
-    checkCodexTerm(content, term) {
-        // Simplified codex term checking
-        switch (term) {
-            case "Type Safety First":
-                return {
-                    passed: !content.includes("any") || content.includes("// @ts-ignore"),
-                    reason: "Type safety violations detected",
-                    recommendation: "Use proper TypeScript types instead of any",
-                    critical: false,
-                };
-            case "No Stubs/Patches":
-                return {
-                    passed: !content.includes("TODO") && !content.includes("FIXME"),
-                    reason: "Stub code or patches detected",
-                    recommendation: "Implement complete functionality or remove placeholder code",
-                    critical: true,
-                };
-            case "Progressive Prod-Ready Code":
-                return {
-                    passed: !content.includes("console.log") || content.includes("production"),
-                    reason: "Non-production ready code detected",
-                    recommendation: "Remove debug statements and ensure production readiness",
-                    critical: false,
-                };
-            default:
-                return {
-                    passed: true,
-                    reason: "",
-                    recommendation: "",
-                    critical: false,
-                };
-        }
-    }
-    enrichWithContext(content, context) {
-        if (context.codex != null) {
-            return `/* 0xRay Framework - Codex Compliant */\n${content}`;
-        }
-        return content;
-    }
-    performSecurityChecks(content) {
-        const warnings = [];
-        if (content.includes("eval(")) {
-            warnings.push("Use of eval() detected - security risk");
-        }
-        if (content.includes("innerHTML")) {
-            warnings.push("Direct innerHTML manipulation detected - XSS risk");
-        }
-        return { warnings };
-    }
-    validateResults(content, results) {
-        if (results.error != null) {
-            return `${content}\n/* ERROR: ${String(results.error)} */`;
-        }
-        return content;
-    }
-    async enforceCompliance(content) {
-        const results = {
-            compliance: [],
-            recommendations: [],
-            approved: true,
-        };
-        // Check bundle size compliance (if applicable)
-        if (content.includes("import") && content.length > 50000) {
-            results.compliance.push("Large module detected - consider code splitting");
-            results.recommendations.push("Implement lazy loading or split large modules");
-        }
-        // Check for performance issues
-        if (content.includes("for") &&
-            content.includes("length") &&
-            content.includes("i++")) {
-            results.recommendations.push("Consider using for...of loops or array methods for better performance");
-        }
-        return results;
-    }
-    generateAuditTrail(content, results, postResults) {
-        const audit = [
-            `Operation completed at ${new Date().toISOString()}`,
-            `Content length: ${content.length}`,
-            `Processing time: ${String(results.duration ?? "unknown")}ms`,
-            `Compliance status: ${postResults.finalApproval ? "approved" : "requires review"}`,
-        ];
-        return audit;
-    }
-    performQualityAssurance(content) {
-        const recommendations = [];
-        // Basic quality checks
-        if (content.split("\n").length > 100) {
-            recommendations.push("Consider breaking down large files into smaller modules");
-        }
-        if (content.includes("function") && content.split("function").length > 10) {
-            recommendations.push("High function count - consider consolidating related functions");
-        }
-        return { recommendations };
-    }
-    detectContentType(content) {
-        if (content.includes("function") ||
-            content.includes("const") ||
-            content.includes("let")) {
-            return "JavaScript/TypeScript";
-        }
-        if (content.includes("class") || content.includes("def ")) {
-            return "Python";
-        }
-        if (content.includes("<") && content.includes(">")) {
-            return "HTML/XML";
-        }
-        return "Text";
-    }
-    async checkFrameworkCompliance(content, operation, context) {
-        const results = {
-            score: 100,
-            criticalIssues: [],
-            warnings: [],
-            actions: [],
-            approved: true,
-        };
-        // Operation-specific compliance checks
-        switch (operation) {
-            case "code-review":
-                if (!content.includes("function") && !content.includes("class")) {
-                    results.warnings.push("No functions or classes detected in code review");
-                }
-                break;
-            case "security-audit":
-                if (!content.includes("auth") && !content.includes("security")) {
-                    results.warnings.push("Limited security-related content detected");
-                }
-                break;
-            case "testing":
-                if (!content.includes("test") && !content.includes("spec")) {
-                    results.warnings.push("No test-related content detected");
-                }
-                break;
-        }
-        // General compliance checks
-        if (content.length > 10000) {
-            results.score -= 10;
-            results.warnings.push("Large content size - consider splitting");
-        }
-        if (results.criticalIssues.length > 0) {
-            results.approved = false;
-            results.score -= 30;
-        }
-        return results;
-    }
-}
-// Start the server if run directly
-if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
-    const server = new XrayProcessorPipelineServer();
-    server.run().catch((error) => frameworkLogger.log("mcps/processor-pipeline", "run", "error", { error: String(error) }));
-}
-export { XrayProcessorPipelineServer };

package/dist/mcps/protocol/protocol-constants.d.ts

@@ -1,46 +0,0 @@
-/**
- * Protocol Constants
- *
- * MCP protocol constants and configuration values.
- * Extracted to enable reuse and single source of truth.
- */
-/**
- * MCP Protocol Version
- * Current MCP protocol specification version
- */
-export declare const MCP_PROTOCOL_VERSION = "2024-11-05";
-/**
- * JSON-RPC Protocol Version
- * Standard JSON-RPC version used by MCP
- */
-export declare const JSONRPC_VERSION = "2.0";
-/**
- * MCP Method Names
- * Standard MCP protocol method identifiers
- */
-export declare const MCP_METHODS: {
-    readonly INITIALIZE: "initialize";
-    readonly TOOLS_LIST: "tools/list";
-    readonly TOOLS_CALL: "tools/call";
-};
-/**
- * Default Timeout Values
- * Millisecond timeouts for various MCP operations
- */
-export declare const DEFAULT_TIMEOUTS: {
-    readonly CONNECTION: 30000;
-    readonly REQUEST: 60000;
-    readonly INITIALIZATION: 10000;
-};
-/**
- * Error Codes
- * Standard JSON-RPC error codes used by MCP
- */
-export declare const ERROR_CODES: {
-    readonly PARSE_ERROR: -32700;
-    readonly INVALID_REQUEST: -32600;
-    readonly METHOD_NOT_FOUND: -32601;
-    readonly INVALID_PARAMS: -32602;
-    readonly INTERNAL_ERROR: -32603;
-    readonly SERVER_ERROR: -32000;
-};

package/dist/mcps/protocol/protocol-constants.js

@@ -1,46 +0,0 @@
-/**
- * Protocol Constants
- *
- * MCP protocol constants and configuration values.
- * Extracted to enable reuse and single source of truth.
- */
-/**
- * MCP Protocol Version
- * Current MCP protocol specification version
- */
-export const MCP_PROTOCOL_VERSION = '2024-11-05';
-/**
- * JSON-RPC Protocol Version
- * Standard JSON-RPC version used by MCP
- */
-export const JSONRPC_VERSION = '2.0';
-/**
- * MCP Method Names
- * Standard MCP protocol method identifiers
- */
-export const MCP_METHODS = {
-    INITIALIZE: 'initialize',
-    TOOLS_LIST: 'tools/list',
-    TOOLS_CALL: 'tools/call',
-};
-/**
- * Default Timeout Values
- * Millisecond timeouts for various MCP operations
- */
-export const DEFAULT_TIMEOUTS = {
-    CONNECTION: 30000,
-    REQUEST: 60000,
-    INITIALIZATION: 10000,
-};
-/**
- * Error Codes
- * Standard JSON-RPC error codes used by MCP
- */
-export const ERROR_CODES = {
-    PARSE_ERROR: -32700,
-    INVALID_REQUEST: -32600,
-    METHOD_NOT_FOUND: -32601,
-    INVALID_PARAMS: -32602,
-    INTERNAL_ERROR: -32603,
-    SERVER_ERROR: -32000,
-};