0xray 4.0.12 → 4.0.13

package/dist/utils/codex-parser.js

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

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

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

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