0xray 4.0.13 → 4.0.15

package/dist/utils/codex-parser.js

@@ -0,0 +1,444 @@
+/**
+ * 0xRay Codex Parser Utility
+ *
+ * Unified parsing utility for codex content in both JSON and Markdown formats.
+ * Provides consistent parsing across all components with format detection and validation.
+ *
+ * @since 2026-01-07
+ */
+import { frameworkLogger } from "../core/framework-logger.js";
+import * as fs from "fs";
+import * as path from "path";
+/**
+ * Maximum length for term descriptions to prevent runaway expansion
+ */
+const MAX_TERM_DESCRIPTION_LENGTH = 2000;
+/**
+ * Sanitize term description to prevent runaway expansion
+ * This guards against corrupted prompts from malformed codex data
+ */
+function sanitizeTermDescription(description) {
+    if (!description || typeof description !== "string") {
+        return "";
+    }
+    // Check for potential runaway expansion patterns
+    if (description.length > MAX_TERM_DESCRIPTION_LENGTH) {
+        frameworkLogger.log("codex-parser", "parse-warning", "warning", {
+            message: `Codex term description exceeded ${MAX_TERM_DESCRIPTION_LENGTH} chars, truncating. This may indicate corrupted codex data.`,
+            length: description.length,
+        });
+        return description.substring(0, MAX_TERM_DESCRIPTION_LENGTH) + "... [TRUNCATED]";
+    }
+    // Check for repeated patterns that indicate corruption
+    const repeatedPattern = /(.+?)\1{5,}/;
+    if (repeatedPattern.test(description)) {
+        frameworkLogger.log("codex-parser", "parse-warning", "warning", {
+            message: "Codex term description contains repeated patterns, indicating potential corruption. Returning sanitized version.",
+        });
+        // Return a minimal safe description
+        return "Term description contains potential corruption.";
+    }
+    return description;
+}
+/**
+ * Get framework version from package.json
+ */
+function getFrameworkVersion() {
+    try {
+        const packageJson = JSON.parse(fs.readFileSync(path.join(process.cwd(), "package.json"), "utf-8"));
+        return packageJson.version || "1.0.0";
+    }
+    catch {
+        return "1.0.0";
+    }
+}
+/**
+ * Detect content format
+ */
+export function detectContentFormat(content) {
+    if (!content || content.trim() === "") {
+        return { format: "unknown", confidence: 0 };
+    }
+    // Check for JSON format
+    const jsonConfidence = (() => {
+        try {
+            JSON.parse(content);
+            return 1.0;
+        }
+        catch {
+            return 0.0; // Not valid JSON
+        }
+    })();
+    // Check for Markdown format
+    const markdownConfidence = (() => {
+        const markdownIndicators = [
+            content.includes("**Version**:"),
+            content.includes("**Last Updated**:"),
+            content.includes("#### "), // Term headers
+            content.includes("## Overview"),
+            content.includes("## Critical Codex Terms"),
+            content.includes("#### 1."), // Common first term
+            content.includes("#### 2."), // Common second term
+        ];
+        return (markdownIndicators.filter(Boolean).length / markdownIndicators.length);
+    })();
+    // Prefer JSON as primary format, Markdown as fallback
+    if (jsonConfidence >= 0.5) {
+        return { format: "json", confidence: jsonConfidence };
+    }
+    else if (markdownConfidence > 0.1) {
+        return { format: "markdown", confidence: markdownConfidence };
+    }
+    return { format: "unknown", confidence: 0 };
+}
+/**
+ * Parse JSON format codex content
+ */
+function parseJsonContent(content) {
+    const warnings = [];
+    try {
+        const jsonData = JSON.parse(content);
+        // Convert terms object to Map
+        const termsMap = new Map();
+        if (jsonData.terms) {
+            Object.entries(jsonData.terms).forEach(([key, term]) => {
+                // Sanitize term description to prevent runaway expansion
+                if (term && term.description) {
+                    term.description = sanitizeTermDescription(term.description);
+                }
+                termsMap.set(parseInt(key, 10), term);
+            });
+        }
+        // Build context from JSON data
+        const context = {
+            version: jsonData.version || "1.2.20",
+            lastUpdated: jsonData.lastUpdated || new Date().toISOString(),
+            terms: termsMap,
+            interweaves: jsonData.interweaves || [],
+            lenses: jsonData.lenses || [],
+            principles: jsonData.principles || [],
+            antiPatterns: jsonData.antiPatterns || [],
+            validationCriteria: jsonData.validationCriteria || {},
+            frameworkAlignment: jsonData.frameworkAlignment || {},
+            errorPreventionTarget: jsonData.errorPreventionTarget || 0.996,
+        };
+        return { success: true, context, warnings };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to parse JSON content: ${error instanceof Error ? error.message : String(error)}`,
+            warnings,
+        };
+    }
+}
+/**
+ * Parse Markdown format codex content
+ */
+function parseMarkdownContent(content) {
+    const warnings = [];
+    try {
+        // Extract version
+        const versionMatch = content.match(/\*\*Version\*\*:\s*([^\n]+)/);
+        const version = versionMatch && versionMatch[1] ? versionMatch[1].trim() : "1.2.20";
+        // Extract last updated
+        const lastUpdatedMatch = content.match(/\*\*Last Updated\*\*:\s*([^\n]+)/);
+        const lastUpdated = lastUpdatedMatch && lastUpdatedMatch[1]
+            ? lastUpdatedMatch[1].trim()
+            : new Date().toISOString();
+        // Extract terms
+        const termsMap = new Map();
+        const termRegex = /^\s*#### (\d+)\.\s*([^\n]+)(?:\s*\n([\s\S]*?))?(?=^\s*#### \d+\.|^\s*## |$)/gm;
+        let match;
+        while ((match = termRegex.exec(content)) !== null) {
+            const termNumber = parseInt(match[1], 10);
+            const termTitle = match[2].trim();
+            const termDescription = sanitizeTermDescription((match[3] || "").trim());
+            // Infer category from term number
+            let category;
+            if (termNumber <= 10) {
+                category = "core";
+            }
+            else if (termNumber <= 20) {
+                category = "extended";
+            }
+            else if (termNumber <= 30) {
+                category = "architecture";
+            }
+            else {
+                category = "advanced";
+            }
+            // Check for zero tolerance indicators
+            const zeroTolerance = termDescription.toLowerCase().includes("zero-tolerance") ||
+                termDescription.toLowerCase().includes("blocking");
+            // Infer enforcement level
+            let enforcementLevel = "low";
+            if (zeroTolerance) {
+                enforcementLevel = "blocking";
+            }
+            else if (termDescription.toLowerCase().includes("blocking")) {
+                enforcementLevel = "blocking";
+            }
+            else if (termDescription.toLowerCase().includes("high")) {
+                enforcementLevel = "high";
+            }
+            else if (termDescription.toLowerCase().includes("medium")) {
+                enforcementLevel = "medium";
+            }
+            const term = {
+                number: termNumber,
+                description: termDescription,
+                category,
+                zeroTolerance,
+                enforcementLevel,
+            };
+            termsMap.set(termNumber, term);
+        }
+        // Extract interweaves, lenses, principles, anti-patterns
+        const interweaves = extractSectionList(content, "Interweaves");
+        const lenses = extractSectionList(content, "Lenses");
+        const principles = extractSectionList(content, "Principles");
+        const antiPatterns = extractSectionList(content, "Anti-Patterns");
+        // Extract validation criteria (simple presence check for now)
+        const validationCriteria = {};
+        const validationSections = [
+            "Code Completeness",
+            "Code Quality",
+            "Code Safety",
+        ];
+        validationSections.forEach((section) => {
+            validationCriteria[section] = content.includes(`### ${section}`);
+        });
+        // Extract framework alignment
+        const frameworkAlignment = {};
+        const frameworkMatch = content.match(/### Framework Alignment([\s\S]*?)(?=### |$)/);
+        if (frameworkMatch && frameworkMatch[1]) {
+            const alignmentText = frameworkMatch[1];
+            const alignmentRegex = /- \*\*([^:]+)\*\*:\s*([^\n]+)/g;
+            let alignmentMatch;
+            while ((alignmentMatch = alignmentRegex.exec(alignmentText)) !== null) {
+                if (alignmentMatch[1] && alignmentMatch[2]) {
+                    frameworkAlignment[alignmentMatch[1].trim()] =
+                        alignmentMatch[2].trim();
+                }
+            }
+        }
+        // Extract error prevention target
+        const targetMatch = content.match(/Error Prevention Target[^:]*:\s*([\d.]+)%?/);
+        const errorPreventionTarget = targetMatch && targetMatch[1] ? parseFloat(targetMatch[1]) / 100 : 0.996;
+        const context = {
+            version,
+            lastUpdated,
+            terms: termsMap,
+            interweaves,
+            lenses,
+            principles,
+            antiPatterns,
+            validationCriteria,
+            frameworkAlignment,
+            errorPreventionTarget,
+        };
+        return { success: true, context, warnings };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to parse Markdown content: ${error instanceof Error ? error.message : String(error)}`,
+            warnings,
+        };
+    }
+}
+/**
+ * Extract section list from markdown content
+ */
+function extractSectionList(content, sectionName) {
+    const sectionRegex = new RegExp(`### ${sectionName}([\\s\\S]*?)(?=### |$)`, "i");
+    const match = content.match(sectionRegex);
+    if (!match || !match[1])
+        return [];
+    const sectionContent = match[1];
+    const listRegex = /- (.+)$/gm;
+    const items = [];
+    let listMatch;
+    while ((listMatch = listRegex.exec(sectionContent)) !== null) {
+        if (listMatch[1]) {
+            items.push(listMatch[1].trim());
+        }
+    }
+    return items;
+}
+/**
+ * Unified codex content parser
+ */
+export function parseCodexContent(content, sourcePath) {
+    // Validate inputs
+    if (!content || content.trim() === "") {
+        return {
+            success: false,
+            error: "Invalid content provided: content cannot be empty",
+            warnings: [],
+        };
+    }
+    if (!sourcePath || sourcePath.trim() === "") {
+        return {
+            success: false,
+            error: "Invalid source path provided",
+            warnings: [],
+        };
+    }
+    // Detect format
+    const formatResult = detectContentFormat(content);
+    // For .json files, try JSON parsing regardless of detection result
+    const isJsonFile = sourcePath && sourcePath.endsWith(".json");
+    if (formatResult.format === "unknown" && !isJsonFile) {
+        return {
+            success: false,
+            error: `Unable to detect content format. Content appears to be neither valid JSON nor Markdown.`,
+            warnings: [`Format detection confidence: ${formatResult.confidence}`],
+        };
+    }
+    // Parse based on detected format or file extension
+    const result = formatResult.format === "json" || isJsonFile
+        ? parseJsonContent(content)
+        : parseMarkdownContent(content);
+    // Add source path to error if available
+    if (!result.success && sourcePath && result.error) {
+        result.error = `${result.error} (source: ${sourcePath})`;
+    }
+    return result;
+}
+/**
+ * Extract codex metadata from content (for compatibility with existing code)
+ */
+export function extractCodexMetadata(content) {
+    const result = parseCodexContent(content, "extract-metadata");
+    if (result.success && result.context) {
+        return {
+            version: result.context.version,
+            termCount: result.context.terms.size,
+        };
+    }
+    // Fallback to old logic for backward compatibility
+    try {
+        const jsonData = JSON.parse(content);
+        const version = jsonData.version || "1.2.20";
+        const termCount = jsonData.terms ? Object.keys(jsonData.terms).length : 0;
+        return { version, termCount };
+    }
+    catch (error) {
+        // Fallback for invalid content
+        return { version: getFrameworkVersion(), termCount: 0 };
+    }
+}
+/**
+ * Validate TypeScript code syntax
+ */
+export async function validateTypeScriptSyntax(code, filePath) {
+    const errors = [];
+    const warnings = [];
+    try {
+        // Use a simpler syntax check for now - basic bracket matching and common syntax issues
+        const bracketStack = [];
+        const brackets = { "{": "}", "[": "]", "(": ")" };
+        for (let i = 0; i < code.length; i++) {
+            const char = code.charAt(i);
+            if (char in brackets) {
+                bracketStack.push(char);
+            }
+            else if (Object.values(brackets).includes(char)) {
+                const lastOpen = bracketStack.pop();
+                if (!lastOpen || brackets[lastOpen] !== char) {
+                    errors.push(`Bracket mismatch at position ${i}: expected closing bracket for '${lastOpen || "none"}', found '${char}'`);
+                }
+            }
+            // Check for common syntax issues
+            if (char === ";" && i > 0 && code.charAt(i - 1) === ";") {
+                warnings.push(`Double semicolon at position ${i}`);
+            }
+        }
+        if (bracketStack.length > 0) {
+            errors.push(`Unclosed brackets: ${bracketStack.join(", ")}`);
+        }
+        // Check for basic import/export syntax
+        const importRegex = /^import\s+.*from\s+['"]/gm;
+        const exportRegex = /^export\s+/gm;
+        let match;
+        while ((match = importRegex.exec(code)) !== null) {
+            if (!match[0].includes("from")) {
+                errors.push(`Invalid import statement at line ${code.substring(0, match.index).split("\n").length}`);
+            }
+        }
+        while ((match = exportRegex.exec(code)) !== null) {
+            // Basic export validation - could be expanded
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    catch (error) {
+        errors.push(`Failed to validate TypeScript syntax: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            valid: false,
+            errors,
+            warnings,
+        };
+    }
+}
+/**
+ * Validate JSON syntax
+ */
+export function validateJsonSyntax(jsonString) {
+    const errors = [];
+    const warnings = [];
+    try {
+        JSON.parse(jsonString);
+        return {
+            valid: true,
+            errors: [],
+            warnings: [],
+        };
+    }
+    catch (error) {
+        errors.push(`Invalid JSON syntax: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            valid: false,
+            errors,
+            warnings,
+        };
+    }
+}
+/**
+ * Comprehensive pre-modification validation
+ */
+export async function validateBeforeModification(content, filePath) {
+    const errors = [];
+    const warnings = [];
+    // Check file extension to determine validation type
+    const isTypeScript = filePath.endsWith(".ts") || filePath.endsWith(".tsx");
+    const isJson = filePath.endsWith(".json");
+    if (isTypeScript) {
+        const tsResult = await validateTypeScriptSyntax(content, filePath);
+        errors.push(...tsResult.errors);
+        warnings.push(...tsResult.warnings);
+    }
+    else if (isJson) {
+        const jsonResult = validateJsonSyntax(content);
+        errors.push(...jsonResult.errors);
+        warnings.push(...jsonResult.warnings);
+    }
+    // Additional content validation
+    if (!content || content.trim() === "") {
+        errors.push("File content is empty or contains only whitespace");
+    }
+    // Check for potential security issues
+    if (content.includes("eval(") || content.includes("Function(")) {
+        warnings.push("Content contains potentially unsafe code execution patterns");
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}

package/dist/utils/command-runner.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Simple command runner utility for executing shell commands
+ */
+export interface CommandResult {
+    success: boolean;
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export interface CommandOptions {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    timeout?: number;
+    silent?: boolean;
+}
+/**
+ * Run a shell command and return the result
+ */
+export declare function runCommand(command: string, options?: CommandOptions): Promise<CommandResult>;
+/**
+ * Run a command and throw on failure
+ */
+export declare function runCommandStrict(command: string, options?: CommandOptions): Promise<string>;
+/**
+ * Run a command safely using spawn with an args array (no shell interpretation).
+ * This prevents command injection when args may contain user-controlled input.
+ */
+export declare function runCommandSafe(command: string, args: string[], options?: CommandOptions): Promise<CommandResult>;
+/**
+ * Run a safe command and throw on failure
+ */
+export declare function runCommandSafeStrict(command: string, args: string[], options?: CommandOptions): Promise<string>;

package/dist/utils/command-runner.js

@@ -0,0 +1,96 @@
+/**
+ * Simple command runner utility for executing shell commands
+ */
+import { exec, spawn } from "child_process";
+import { promisify } from "util";
+const execAsync = promisify(exec);
+/**
+ * Run a shell command and return the result
+ */
+export async function runCommand(command, options = {}) {
+    try {
+        const { stdout, stderr } = await execAsync(command, {
+            cwd: options.cwd || process.cwd(),
+            env: { ...process.env, ...options.env },
+            timeout: options.timeout || 30000, // 30 second default timeout
+            maxBuffer: 1024 * 1024 * 10, // 10MB buffer
+        });
+        return {
+            success: true,
+            stdout: stdout.toString().trim(),
+            stderr: stderr.toString().trim(),
+            exitCode: 0,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            stdout: error.stdout?.toString().trim() || "",
+            stderr: error.stderr?.toString().trim() || error.message || "Command failed",
+            exitCode: error.code || 1,
+        };
+    }
+}
+/**
+ * Run a command and throw on failure
+ */
+export async function runCommandStrict(command, options = {}) {
+    const result = await runCommand(command, options);
+    if (!result.success) {
+        throw new Error(`Command failed: ${command}\n${result.stderr}`);
+    }
+    return result.stdout;
+}
+/**
+ * Run a command safely using spawn with an args array (no shell interpretation).
+ * This prevents command injection when args may contain user-controlled input.
+ */
+export async function runCommandSafe(command, args, options = {}) {
+    return new Promise((resolve) => {
+        const child = spawn(command, args, {
+            cwd: options.cwd || process.cwd(),
+            env: { ...process.env, ...options.env },
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        const timeout = options.timeout || 30000;
+        const timer = setTimeout(() => {
+            child.kill("SIGTERM");
+        }, timeout);
+        child.stdout.on("data", (data) => {
+            stdout += data.toString();
+        });
+        child.stderr.on("data", (data) => {
+            stderr += data.toString();
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            resolve({
+                success: code === 0,
+                stdout: stdout.trim(),
+                stderr: stderr.trim(),
+                exitCode: code ?? 1,
+            });
+        });
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            resolve({
+                success: false,
+                stdout: "",
+                stderr: err.message,
+                exitCode: 1,
+            });
+        });
+    });
+}
+/**
+ * Run a safe command and throw on failure
+ */
+export async function runCommandSafeStrict(command, args, options = {}) {
+    const result = await runCommandSafe(command, args, options);
+    if (!result.success) {
+        throw new Error(`Command failed: ${command} ${args.join(" ")}\n${result.stderr}`);
+    }
+    return result.stdout;
+}

package/dist/utils/import-resolver.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Import Resolver Utility
+ * Dynamically resolves module imports across different environments
+ *
+ * This solves the systemic path resolution issue where hardcoded paths
+ * break between development, built, and deployed environments.
+ */
+export declare class ImportResolver {
+    private static instance;
+    private currentDir;
+    private projectRoot;
+    private isDevelopment;
+    private isBuilt;
+    private isInstalled;
+    private isTesting;
+    private constructor();
+    static getInstance(): ImportResolver;
+    private getCurrentDirectory;
+    private findProjectRoot;
+    private fileExists;
+    private detectDevelopment;
+    private detectBuilt;
+    private detectInstalled;
+    private detectTesting;
+    /**
+     * Resolve module import path for any module
+     */
+    resolveModulePath(moduleName: string, subPath?: string): string;
+    /**
+     * Resolve agent import path (special case for agents)
+     */
+    resolveAgentPath(agentName: string): string;
+    /**
+     * Dynamic import with comprehensive environment resolution
+     */
+    importModule(moduleName: string, subPath?: string): Promise<any>;
+    /**
+     * Generate alternative import paths for fallback
+     */
+    private generateAlternativePaths;
+    /**
+     * Get comprehensive environment information
+     */
+    getEnvironmentInfo(): {
+        currentDir: string;
+        projectRoot: string;
+        isDevelopment: boolean;
+        isBuilt: boolean;
+        isInstalled: boolean;
+        isTesting: boolean;
+        nodeEnv: string | undefined;
+    };
+}
+export declare const importResolver: ImportResolver;