0xray 2.0.0

package/dist/processors/implementations/typescript-compilation-processor.js

@@ -0,0 +1,87 @@
+/**
+ * TypeScript Compilation Processor
+ *
+ * Runs `tsc --noEmit` to catch type errors before writes land.
+ * Parses TypeScript error lines from stderr and returns structured results.
+ * Gracefully skips when no tsconfig.json exists.
+ *
+ * @version 1.0.0
+ * @since 2026-03-28
+ */
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { frameworkLogger } from "../../core/framework-logger.js";
+/**
+ * Parse TypeScript error lines from stderr output.
+ * Filters for lines containing "error TS" which is the standard TypeScript error format.
+ */
+export function parseTypeScriptErrors(stderr) {
+    return stderr
+        .split("\n")
+        .filter((line) => line.includes("error TS"))
+        .map((line) => line.trim());
+}
+/**
+ * Run TypeScript compilation check (tsc --noEmit).
+ *
+ * @param cwd - Working directory for the command (defaults to process.cwd())
+ * @param timeout - Maximum execution time in milliseconds (default 30000)
+ * @returns Structured result with success status, errors, and timing
+ */
+export function runTypeScriptCompilation(cwd, timeout = 30000) {
+    const startTime = Date.now();
+    const workingDir = cwd || process.cwd();
+    frameworkLogger.log("typescript-compilation-processor", "starting tsc --noEmit check", "info", { cwd: workingDir, timeout });
+    // Check if tsconfig.json exists in the working directory
+    if (!existsSync(`${workingDir}/tsconfig.json`)) {
+        frameworkLogger.log("typescript-compilation-processor", "skipped - no tsconfig.json found", "info", { cwd: workingDir });
+        return {
+            success: true,
+            errors: [],
+            duration: Date.now() - startTime,
+            fileCount: 0,
+            skipped: true,
+            reason: "no tsconfig.json found",
+        };
+    }
+    try {
+        execSync("npx tsc --noEmit", {
+            cwd: workingDir,
+            stdio: "pipe",
+            timeout,
+        });
+        frameworkLogger.log("typescript-compilation-processor", "tsc --noEmit passed with no errors", "success", { duration: Date.now() - startTime });
+        return {
+            success: true,
+            errors: [],
+            duration: Date.now() - startTime,
+            fileCount: 0,
+        };
+    }
+    catch (error) {
+        const err = error;
+        const stderr = err.stderr?.toString() || err.message || "";
+        const errorLines = parseTypeScriptErrors(stderr);
+        frameworkLogger.log("typescript-compilation-processor", "tsc --noEmit found type errors", "error", {
+            errorCount: errorLines.length,
+            duration: Date.now() - startTime,
+            errors: errorLines.slice(0, 10), // Log first 10 errors for debugging
+        });
+        return {
+            success: false,
+            errors: errorLines.length > 0 ? errorLines : [stderr],
+            duration: Date.now() - startTime,
+            fileCount: 0,
+            errorCount: errorLines.length,
+        };
+    }
+}
+export const typescriptCompilationProcessor = {
+    name: "typescriptCompilation",
+    priority: 15,
+    enabled: true,
+    async execute(context) {
+        const cwd = context.directory || process.cwd();
+        return runTypeScriptCompilation(cwd);
+    },
+};

package/dist/processors/implementations/version-compliance-processor.js

@@ -0,0 +1,350 @@
+/**
+ * Version Compliance Processor
+ *
+ * Pre-processor that enforces version compliance rules before allowing
+ * commits or publishes. Integrates with 0xRay's processor pipeline.
+ *
+ * Rules Enforced:
+ * 1. Universal Version Manager MUST be 1 ahead of NPM published version
+ * 2. package.json SHOULD match UVM (warning if not)
+ * 3. Source files MUST be synchronized to UVM version
+ * 4. README SHOULD reference current version
+ *
+ * @processor_type pre
+ * @priority 25 (high - runs early, after preValidate, before errorBoundary)
+ * @blocking true (blocks on violations)
+ *
+ * @version 1.0.0
+ * @framework 0xRay 1.3.5
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { exec as execSync } from "child_process";
+import { promisify } from "util";
+import { frameworkLogger } from "../../core/framework-logger.js";
+const exec = promisify(execSync);
+export class VersionComplianceProcessor {
+    projectRoot;
+    errors = [];
+    warnings = [];
+    fixes = [];
+    constructor(projectRoot = process.cwd()) {
+        this.projectRoot = projectRoot;
+    }
+    /**
+     * Main execution method - called by ProcessorManager
+     */
+    async execute(context) {
+        try {
+            // Only validate on relevant operations
+            const relevantOperations = [
+                "write",
+                "edit",
+                "multiedit",
+                "version",
+                "publish",
+            ];
+            if (!relevantOperations.includes(context.tool) &&
+                !context.operation.includes("version")) {
+                return {
+                    success: true,
+                    blocked: false,
+                    message: "Version compliance skipped (not a version-related operation)",
+                };
+            }
+            const result = await this.validateVersionCompliance();
+            if (!result.compliant) {
+                await frameworkLogger.log("version-compliance-processor", "-version-compliance-failed-", "error", {
+                    errors: result.errors,
+                    warnings: result.warnings,
+                    npmVersion: result.npmVersion,
+                    uvmVersion: result.uvmVersion,
+                    pkgVersion: result.pkgVersion,
+                });
+                return {
+                    success: false,
+                    blocked: true,
+                    message: `Version compliance failed: ${result.errors.join(", ")}`,
+                    result,
+                };
+            }
+            // Log success
+            await frameworkLogger.log("version-compliance-processor", "-version-compliance-passed-", "info", {
+                npmVersion: result.npmVersion,
+                uvmVersion: result.uvmVersion,
+                pkgVersion: result.pkgVersion,
+                warnings: result.warnings,
+            });
+            return {
+                success: true,
+                blocked: false,
+                message: result.warnings.length > 0
+                    ? `Version compliance passed with ${result.warnings.length} warnings`
+                    : "Version compliance passed",
+                result,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            await frameworkLogger.log("version-compliance-processor", "-validation-error-", "error", { message: errorMessage });
+            return {
+                success: false,
+                blocked: true,
+                message: `Version compliance error: ${errorMessage}`,
+            };
+        }
+    }
+    /**
+     * Validate all version compliance rules
+     */
+    async validateVersionCompliance() {
+        this.errors = [];
+        this.warnings = [];
+        this.fixes = [];
+        // Get all versions
+        const npmVersion = await this.getNpmVersion();
+        const uvmVersion = this.getUvmVersion();
+        const pkgVersion = this.getPackageVersion();
+        // Rule 1: UVM MUST be 1 ahead of NPM
+        if (npmVersion !== "NOT_PUBLISHED" && npmVersion !== "ERROR") {
+            const npmParsed = this.parseVersion(npmVersion);
+            const uvmParsed = this.parseVersion(uvmVersion);
+            const expectedUvm = this.incrementPatch(npmParsed);
+            if (uvmVersion !== this.formatVersion(expectedUvm)) {
+                this.errors.push(`Version manager not 1 ahead of npm (NPM: ${npmVersion}, UVM: ${uvmVersion}, Expected: ${this.formatVersion(expectedUvm)})`);
+                this.fixes.push({
+                    type: "update-uvm",
+                    description: `Update UVM to ${this.formatVersion(expectedUvm)}`,
+                    command: "node scripts/node/universal-version-manager.js",
+                    autoFixable: false, // Requires manual edit
+                });
+            }
+        }
+        // Rule 2: package.json SHOULD match UVM
+        if (pkgVersion !== uvmVersion) {
+            this.warnings.push(`package.json version (${pkgVersion}) doesn't match UVM (${uvmVersion}) - run "npm version [patch|minor|major]" to sync`);
+        }
+        // Rule 3: Source files MUST be synchronized
+        const sourceVersion = this.getSourceVersion();
+        if (sourceVersion && sourceVersion !== uvmVersion) {
+            this.errors.push(`Source files not synchronized to UVM version (${sourceVersion} vs ${uvmVersion})`);
+            this.fixes.push({
+                type: "sync-source",
+                description: "Synchronize source files to UVM version",
+                command: "node scripts/node/universal-version-manager.js",
+                autoFixable: true,
+            });
+        }
+        // Rule 4: README SHOULD reference current version
+        const readmeVersion = this.getReadmeVersion();
+        if (readmeVersion &&
+            readmeVersion !== uvmVersion &&
+            readmeVersion !== pkgVersion) {
+            this.warnings.push(`README version (${readmeVersion}) may be outdated (UVM: ${uvmVersion}, package: ${pkgVersion})`);
+            this.fixes.push({
+                type: "update-readme",
+                description: "Update README version references",
+                command: "node scripts/node/universal-version-manager.js",
+                autoFixable: true,
+            });
+        }
+        return {
+            compliant: this.errors.length === 0,
+            npmVersion,
+            uvmVersion,
+            pkgVersion,
+            errors: this.errors,
+            warnings: this.warnings,
+            fixes: this.fixes,
+        };
+    }
+    /**
+     * Get NPM published version
+     */
+    async getNpmVersion() {
+        try {
+            const { stdout } = await exec('npm view 0xray@latest version 2>/dev/null || echo "NOT_PUBLISHED"', {
+                cwd: this.projectRoot,
+                timeout: 10000,
+            });
+            return stdout?.trim() || "NOT_PUBLISHED";
+        }
+        catch {
+            return "NOT_PUBLISHED";
+        }
+    }
+    /**
+     * Get Universal Version Manager version
+     */
+    getUvmVersion() {
+        try {
+            const uvmPath = path.join(this.projectRoot, "scripts", "node", "universal-version-manager.js");
+            if (!fs.existsSync(uvmPath)) {
+                return "NOT_FOUND";
+            }
+            const content = fs.readFileSync(uvmPath, "utf-8");
+            // Match version in OFFICIAL_VERSIONS.framework.version format
+            const match = content.match(/OFFICIAL_VERSIONS\s*=\s*\{[\s\S]*?framework:\s*\{[\s\S]*?version:\s*["']([^"']+)["']/);
+            if (match && match[1]) {
+                return match[1];
+            }
+            // Fallback: grep for version pattern
+            const fallbackMatch = content.match(/version:\s*["'](\d+\.\d+\.\d+)["']/);
+            return fallbackMatch && fallbackMatch[1] ? fallbackMatch[1] : "NOT_FOUND";
+        }
+        catch {
+            return "ERROR";
+        }
+    }
+    /**
+     * Get package.json version
+     */
+    getPackageVersion() {
+        try {
+            const pkgPath = path.join(this.projectRoot, "package.json");
+            if (!fs.existsSync(pkgPath)) {
+                return "NOT_FOUND";
+            }
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+            return pkg?.version || "NOT_FOUND";
+        }
+        catch {
+            return "ERROR";
+        }
+    }
+    /**
+     * Get version from source files
+     */
+    getSourceVersion() {
+        try {
+            const cliPath = path.join(this.projectRoot, "src", "cli", "index.ts");
+            if (!fs.existsSync(cliPath)) {
+                return null;
+            }
+            const content = fs.readFileSync(cliPath, "utf-8");
+            const match = content.match(/\.version\(["']([^"']+)["']\)/);
+            return match && match[1] ? match[1] : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Get version from README
+     */
+    getReadmeVersion() {
+        try {
+            const readmePath = path.join(this.projectRoot, "README.md");
+            if (!fs.existsSync(readmePath)) {
+                return null;
+            }
+            const content = fs.readFileSync(readmePath, "utf-8");
+            // Match vX.Y.Z or X.Y.Z patterns - but exclude IP addresses (127.x.x)
+            // Look for version in badges, headers, or specific patterns
+            const match = content.match(/v?(1\.\d+\.\d+)/);
+            return match && match[1] ? match[1] : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Parse version string into components
+     */
+    parseVersion(version) {
+        const parts = version.split(".");
+        return {
+            major: parseInt(parts[0] || "0", 10),
+            minor: parseInt(parts[1] || "0", 10),
+            patch: parseInt(parts[2] || "0", 10),
+            raw: version,
+        };
+    }
+    /**
+     * Format version components back to string
+     */
+    formatVersion(version) {
+        return `${version.major}.${version.minor}.${version.patch}`;
+    }
+    /**
+     * Increment patch version
+     */
+    incrementPatch(version) {
+        return {
+            ...version,
+            patch: version.patch + 1,
+        };
+    }
+    /**
+     * Auto-fix version compliance issues
+     */
+    async autoFix() {
+        const result = await this.validateVersionCompliance();
+        const fixed = [];
+        const failed = [];
+        for (const fix of result.fixes || []) {
+            if (fix.autoFixable) {
+                try {
+                    const { stdout, stderr } = await exec(fix.command, {
+                        cwd: this.projectRoot,
+                        timeout: 30000,
+                    });
+                    if (stderr) {
+                        failed.push(`${fix.type}: ${stderr}`);
+                    }
+                    else {
+                        fixed.push(fix.type);
+                    }
+                }
+                catch (error) {
+                    failed.push(`${fix.type}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            else {
+                failed.push(`${fix.type}: Manual fix required`);
+            }
+        }
+        return {
+            success: failed.length === 0,
+            fixed,
+            failed,
+        };
+    }
+    /**
+     * Generate compliance report
+     */
+    generateReport(result) {
+        const lines = [
+            "🔍 Version Compliance Report",
+            "============================",
+            "",
+            `NPM Published: ${result.npmVersion}`,
+            `Version Manager: ${result.uvmVersion}`,
+            `package.json: ${result.pkgVersion}`,
+            "",
+            result.compliant ? "✅ COMPLIANT" : "❌ NON-COMPLIANT",
+            "",
+        ];
+        if (result.errors.length > 0) {
+            lines.push("Errors:");
+            result.errors.forEach((e) => lines.push(`  ❌ ${e}`));
+            lines.push("");
+        }
+        if (result.warnings.length > 0) {
+            lines.push("Warnings:");
+            result.warnings.forEach((w) => lines.push(`  ⚠️  ${w}`));
+            lines.push("");
+        }
+        if (result.fixes && result.fixes.length > 0) {
+            lines.push("Suggested Fixes:");
+            result.fixes.forEach((f) => {
+                lines.push(`  🔧 ${f.description}`);
+                lines.push(`     Command: ${f.command}`);
+                lines.push(`     Auto-fixable: ${f.autoFixable ? "Yes" : "No"}`);
+            });
+        }
+        return lines.join("\n");
+    }
+}
+// Export singleton for processor registration
+export const versionComplianceProcessor = new VersionComplianceProcessor();

package/dist/processors/processor-interfaces.js

@@ -0,0 +1,126 @@
+/**
+ * Processor Interface and Base Classes
+ *
+ * Defines the contract for all processors in the 0xRay framework.
+ * Replaces the switch statement anti-pattern in ProcessorManager with
+ * polymorphic processor classes.
+ *
+ * @module processors/interfaces
+ * @version 1.0.0
+ */
+export class BaseProcessor {
+    enabled = true;
+    static dependencies;
+    /**
+     * Execute the processor with error handling and metrics
+     * @param context Processor execution context
+     * @returns Processor result
+     */
+    async execute(context) {
+        const startTime = Date.now();
+        try {
+            const data = await this.run(context);
+            const duration = Date.now() - startTime;
+            return {
+                success: true,
+                data,
+                duration,
+                processorName: this.name,
+            };
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                duration,
+                processorName: this.name,
+            };
+        }
+    }
+    /**
+     * Safely extract file path from context
+     */
+    getFilePath(context) {
+        return context.toolInput?.args?.filePath || context.filePath;
+    }
+    /**
+     * Safely extract content from context
+     */
+    getContent(context) {
+        return context.toolInput?.args?.content;
+    }
+}
+/**
+ * Pre-processor base class
+ */
+export class PreProcessor extends BaseProcessor {
+    type = "pre";
+}
+/**
+ * Post-processor base class
+ */
+export class PostProcessor extends BaseProcessor {
+    type = "post";
+}
+/**
+ * Processor registry for managing processor instances
+ */
+export class ProcessorRegistry {
+    processors = new Map();
+    /**
+     * Register a processor
+     * @param processor Processor instance
+     */
+    register(processor) {
+        this.processors.set(processor.name, processor);
+    }
+    /**
+     * Unregister a processor
+     * @param name Processor name
+     */
+    unregister(name) {
+        this.processors.delete(name);
+    }
+    /**
+     * Get a processor by name
+     * @param name Processor name
+     * @returns Processor instance or undefined
+     */
+    get(name) {
+        return this.processors.get(name);
+    }
+    /**
+     * Get all registered processors
+     * @returns Array of processors
+     */
+    getAll() {
+        return Array.from(this.processors.values());
+    }
+    /**
+     * Get processors by type
+     * @param type Processor type
+     * @returns Array of processors
+     */
+    getByType(type) {
+        return this.getAll()
+            .filter((p) => p.type === type)
+            .sort((a, b) => a.priority - b.priority);
+    }
+    /**
+     * Check if processor exists
+     * @param name Processor name
+     * @returns True if processor exists
+     */
+    has(name) {
+        return this.processors.has(name);
+    }
+    /**
+     * Clear all processors
+     */
+    clear() {
+        this.processors.clear();
+    }
+}
+// Singleton registry instance
+export const processorRegistry = new ProcessorRegistry();