0xray 2.1.4 → 2.2.0

package/dist/utils/batch-operations.js

@@ -1,292 +0,0 @@
-import { spawn } from "child_process";
-import * as fs from "fs";
-import * as path from "path";
-import { getBatchOperations } from "../core/features-config.js";
-/**
- * Validate operation is safe for command execution
- * Prevents command injection by validating patterns and replacements
- */
-function validateSafeString(str, operationType) {
-    // Allow only alphanumeric, basic regex characters, and whitespace
-    // SECURITY: Blocks shell metacharacters that could enable command injection
-    const safePattern = /^[a-zA-Z0-9\s\-_.@\\{}()*+?^$.|<>]+$/;
-    const isSafe = safePattern.test(str) && str.length <= 200;
-    if (!isSafe) {
-        const errorMsg = operationType
-            ? `Invalid ${operationType} operation: ${str}`
-            : `Invalid operation: ${str}`;
-        throw new Error(errorMsg);
-    }
-    return isSafe;
-}
-/**
- * Validate operation type and pattern/replacement strings
- */
-function validateOperation(op) {
-    // For FileOperation, validate the operation type
-    if ("operation" in op) {
-        const allowedOperations = ["replace", "append", "prepend", "delete"];
-        if (!allowedOperations.includes(op.operation)) {
-            throw new Error(`Invalid operation type: ${op.operation}`);
-        }
-    }
-    // For ReplacementOperation, validate pattern/replacement strings
-    if ("pattern" in op) {
-        // Validate pattern string for command injection prevention
-        if (op.pattern) {
-            validateSafeString(op.pattern, 'pattern');
-        }
-        // Validate replacement string if it exists (ReplacementOperation only)
-        if ("replacement" in op && op.replacement) {
-            validateSafeString(op.replacement, 'replacement');
-        }
-    }
-    // Validate content if it exists (FileOperation only)
-    if ("content" in op && op.content) {
-        validateSafeString(op.content, 'content');
-    }
-}
-function escapeForSed(str) {
-    return str.replace(/[\/&]/g, "\\$&");
-}
-function escapeForGrep(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-export async function batchReplace(files, operations) {
-    const startTime = Date.now();
-    const config = getBatchOperations();
-    if (!config.enabled) {
-        return executeSequential(files, operations, startTime);
-    }
-    const firstOperation = operations[0];
-    if (config.prefer_sed_for_replacements &&
-        operations.length === 1 &&
-        firstOperation) {
-        return executeSedBatch(files, firstOperation, startTime);
-    }
-    if (config.parallel_file_updates &&
-        files.length > config.auto_batch_threshold) {
-        return executeParallelBatch(files, operations, config.max_concurrent_edits, startTime);
-    }
-    return executeSequential(files, operations, startTime);
-}
-/**
- * Execute sed command using spawn to prevent command injection
- * SECURITY: Uses array arguments to prevent shell injection attacks
- */
-async function executeSedBatch(files, operation, startTime) {
-    const errors = [];
-    let filesModified = 0;
-    const pattern = operation.isRegex
-        ? operation.pattern
-        : escapeForGrep(operation.pattern);
-    const replacement = escapeForSed(operation.replacement);
-    const sedFlags = operation.caseSensitive ? "g" : "gi";
-    for (const file of files) {
-        try {
-            if (!fs.existsSync(file)) {
-                errors.push({ file, error: "File not found" });
-                continue;
-            }
-            // SECURITY FIX: Use spawn with array arguments to prevent command injection
-            // This avoids shell interpretation and injection attacks
-            const args = ["-i", "", `s/${pattern}/${replacement}/${sedFlags}`, file];
-            await new Promise((resolve, reject) => {
-                const sedProcess = spawn("sed", args);
-                let stderr = "";
-                sedProcess.stderr?.on("data", (data) => {
-                    stderr += data.toString();
-                });
-                sedProcess.on("close", (code) => {
-                    if (code === 0) {
-                        resolve();
-                    }
-                    else {
-                        reject(new Error(`sed failed with code ${code}: ${stderr}`));
-                    }
-                });
-                sedProcess.on("error", (err) => {
-                    reject(new Error(`Failed to spawn sed: ${err.message}`));
-                });
-            });
-            filesModified++;
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : String(err);
-            errors.push({ file, error: errorMessage });
-        }
-    }
-    return {
-        success: errors.length === 0,
-        filesModified,
-        errors,
-        duration: Date.now() - startTime,
-    };
-}
-async function executeParallelBatch(files, operations, maxConcurrent, startTime) {
-    const errors = [];
-    let filesModified = 0;
-    const chunks = [];
-    for (let i = 0; i < files.length; i += maxConcurrent) {
-        chunks.push(files.slice(i, i + maxConcurrent));
-    }
-    for (const chunk of chunks) {
-        const promises = chunk.map(async (file) => {
-            try {
-                await processFileOperations(file, operations);
-                return { file, success: true };
-            }
-            catch (err) {
-                const errorMessage = err instanceof Error ? err.message : String(err);
-                return { file, success: false, error: errorMessage };
-            }
-        });
-        const results = await Promise.all(promises);
-        for (const result of results) {
-            if (result.success) {
-                filesModified++;
-            }
-            else if (result.error) {
-                errors.push({ file: result.file, error: result.error });
-            }
-        }
-    }
-    return {
-        success: errors.length === 0,
-        filesModified,
-        errors,
-        duration: Date.now() - startTime,
-    };
-}
-async function executeSequential(files, operations, startTime) {
-    const errors = [];
-    let filesModified = 0;
-    for (const file of files) {
-        try {
-            await processFileOperations(file, operations);
-            filesModified++;
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : String(err);
-            errors.push({ file, error: errorMessage });
-        }
-    }
-    return {
-        success: errors.length === 0,
-        filesModified,
-        errors,
-        duration: Date.now() - startTime,
-    };
-}
-async function processFileOperations(filePath, operations) {
-    if (!fs.existsSync(filePath)) {
-        throw new Error(`File not found: ${filePath}`);
-    }
-    let content = fs.readFileSync(filePath, "utf-8");
-    let modified = false;
-    for (const op of operations) {
-        const flags = op.caseSensitive ? "g" : "gi";
-        const regex = op.isRegex
-            ? new RegExp(op.pattern, flags)
-            : new RegExp(escapeForGrep(op.pattern), flags);
-        if (regex.test(content)) {
-            content = content.replace(regex, op.replacement);
-            modified = true;
-        }
-    }
-    if (modified) {
-        fs.writeFileSync(filePath, content, "utf-8");
-    }
-}
-export async function batchFileOperations(operations) {
-    const startTime = Date.now();
-    const errors = [];
-    let filesModified = 0;
-    for (const op of operations) {
-        try {
-            switch (op.operation) {
-                case "replace":
-                    if (op.pattern && op.content) {
-                        await processFileOperations(op.filePath, [
-                            { pattern: op.pattern, replacement: op.content },
-                        ]);
-                    }
-                    break;
-                case "append":
-                    if (op.content) {
-                        const existing = fs.existsSync(op.filePath)
-                            ? fs.readFileSync(op.filePath, "utf-8")
-                            : "";
-                        fs.writeFileSync(op.filePath, existing + op.content, "utf-8");
-                    }
-                    break;
-                case "prepend":
-                    if (op.content) {
-                        const existing = fs.existsSync(op.filePath)
-                            ? fs.readFileSync(op.filePath, "utf-8")
-                            : "";
-                        fs.writeFileSync(op.filePath, op.content + existing, "utf-8");
-                    }
-                    break;
-                case "delete":
-                    if (fs.existsSync(op.filePath)) {
-                        fs.unlinkSync(op.filePath);
-                    }
-                    break;
-            }
-            filesModified++;
-        }
-        catch (err) {
-            const errorMessage = err instanceof Error ? err.message : String(err);
-            errors.push({ file: op.filePath, error: errorMessage });
-        }
-    }
-    return {
-        success: errors.length === 0,
-        filesModified,
-        errors,
-        duration: Date.now() - startTime,
-    };
-}
-export function findFilesWithPattern(directory, pattern, extensions = [".ts", ".tsx", ".js", ".jsx", ".json"]) {
-    const results = [];
-    function searchDir(dir) {
-        const entries = fs.readdirSync(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            const fullPath = path.join(dir, entry.name);
-            if (entry.name.startsWith(".") || entry.name === "node_modules") {
-                continue;
-            }
-            if (entry.isDirectory()) {
-                searchDir(fullPath);
-            }
-            else if (entry.isFile()) {
-                const ext = path.extname(entry.name);
-                if (extensions.includes(ext)) {
-                    try {
-                        const content = fs.readFileSync(fullPath, "utf-8");
-                        if (content.includes(pattern)) {
-                            results.push(fullPath);
-                        }
-                    }
-                    catch {
-                        continue;
-                    }
-                }
-            }
-        }
-    }
-    searchDir(directory);
-    return results;
-}
-export async function bulkRename(directory, oldName, newName, extensions = [".ts", ".tsx", ".js", ".jsx"]) {
-    const files = findFilesWithPattern(directory, oldName, extensions);
-    return batchReplace(files, [
-        {
-            pattern: oldName,
-            replacement: newName,
-            isRegex: false,
-            caseSensitive: true,
-        },
-    ]);
-}

package/dist/utils/test-template-generator.d.ts

@@ -1,25 +0,0 @@
-/**
- * Test Template Generator for 0xRay Framework
- *
- * Automatically generates test templates for different file types
- * to ensure consistent test coverage and structure.
- */
-export interface TestTemplateOptions {
-    filePath: string;
-    componentName?: string;
-    exports?: string[];
-    isReact?: boolean;
-    isTypeScript?: boolean;
-}
-/**
- * Generate a test template based on file type and structure
- */
-export declare function generateTestTemplate(options: TestTemplateOptions): string;
-/**
- * Analyze a source file to extract exports for test generation
- */
-export declare function analyzeSourceFile(filePath: string): {
-    exports: string[];
-    isReact: boolean;
-    isTypeScript: boolean;
-};

package/dist/utils/test-template-generator.js

@@ -1,178 +0,0 @@
-/**
- * Test Template Generator for 0xRay Framework
- *
- * Automatically generates test templates for different file types
- * to ensure consistent test coverage and structure.
- */
-import { frameworkLogger } from "../core/framework-logger.js";
-import fs from "fs";
-/**
- * Generate a test template based on file type and structure
- */
-export function generateTestTemplate(options) {
-    const { filePath, componentName, exports = [], isReact = false, isTypeScript = false, } = options;
-    const fileName = filePath
-        .split("/")
-        .pop()
-        ?.replace(/\.(ts|tsx|js|jsx)$/, "") || "Unknown";
-    const testFileName = `${fileName}.test.${isTypeScript ? "ts" : "js"}${isReact ? "x" : ""}`;
-    if (isReact) {
-        return generateReactTestTemplate(fileName, componentName || fileName, isTypeScript);
-    }
-    return generateUnitTestTemplate(fileName, exports, isTypeScript);
-}
-/**
- * Generate React component test template
- */
-function generateReactTestTemplate(fileName, componentName, isTypeScript) {
-    const typeAnnotation = isTypeScript ? ": RenderResult" : "";
-    const typeImport = isTypeScript ? ", RenderResult" : "";
-    return `import { render, screen } from '@testing-library/react';
-import { expect, describe, it${typeImport} } from '${isTypeScript ? "vitest" : "jest"}';
-import { ${componentName} } from './${fileName}';
-
-describe('${componentName}', () => {
-  it('should render successfully', () => {
-    const { container }${typeAnnotation} = render(<${componentName} />);
-    expect(container).toBeInTheDocument();
-  });
-
-  it('should render with default props', () => {
-    render(<${componentName} />);
-    // Add specific assertions based on component behavior
-    expect(screen.getByRole('generic')).toBeInTheDocument();
-  });
-
-  // Add more test cases based on component props and behavior
-  // it('should handle prop changes', () => {
-  //   const { rerender } = render(<${componentName} prop="value" />);
-  //   expect(screen.getByText('value')).toBeInTheDocument();
-  //
-  //   rerender(<${componentName} prop="newValue" />);
-  //   expect(screen.getByText('newValue')).toBeInTheDocument();
-  // });
-
-  // Add accessibility tests
-  it('should be accessible', () => {
-    const { container } = render(<${componentName} />);
-    expect(container).toBeAccessible();
-  });
-});
-`;
-}
-/**
- * Generate unit test template for utility functions/classes
- */
-function generateUnitTestTemplate(fileName, exports, isTypeScript) {
-    const describeBlocks = exports
-        .map((exportName) => {
-        if (exportName.match(/^[A-Z]/)) {
-            // Class export
-            return generateClassTestTemplate(exportName);
-        }
-        else {
-            // Function export
-            return generateFunctionTestTemplate(exportName);
-        }
-    })
-        .join("\n\n");
-    return `import { expect, describe, it } from '${isTypeScript ? "vitest" : "jest"}';
-${exports.length > 0 ? `import { ${exports.join(", ")} } from './${fileName}';` : `// import functions from './${fileName}'`}
-
-${describeBlocks}
-
-describe('${fileName}', () => {
-  // Add general module tests here
-  it('should export expected functions', () => {
-    ${exports.length > 0 ? exports.map((exp) => `expect(typeof ${exp}).toBe('function');`).join("\n    ") : "// Add export tests"}
-  });
-});
-`;
-}
-/**
- * Generate test template for a class
- */
-function generateClassTestTemplate(className) {
-    return `describe('${className}', () => {
-  let instance: ${className};
-
-  beforeEach(() => {
-    // instance = new ${className}();
-  });
-
-  it('should create instance successfully', () => {
-    // expect(instance).toBeInstanceOf(${className});
-    expect(true).toBe(true); // Placeholder test
-  });
-
-  // Add method tests
-  // it('should have expected methods', () => {
-  //   expect(typeof instance.methodName).toBe('function');
-  // });
-
-  // Add property tests
-  // it('should have expected properties', () => {
-  //   expect(instance.propertyName).toBeDefined();
-  // });
-});`;
-}
-/**
- * Generate test template for a function
- */
-function generateFunctionTestTemplate(functionName) {
-    return `describe('${functionName}', () => {
-  it('should be a function', () => {
-    expect(typeof ${functionName}).toBe('function');
-  });
-
-  it('should handle basic input', () => {
-    // const result = ${functionName}(/* test input */);
-    // expect(result).toBe(/* expected output */);
-    expect(true).toBe(true); // Placeholder test
-  });
-
-  it('should handle edge cases', () => {
-    // Test null, undefined, empty inputs
-    // expect(() => ${functionName}(null)).toThrow();
-    expect(true).toBe(true); // Placeholder test
-  });
-
-  // Add more specific test cases based on function behavior
-});`;
-}
-/**
- * Analyze a source file to extract exports for test generation
- */
-export function analyzeSourceFile(filePath) {
-    try {
-        const content = fs.readFileSync(filePath, "utf-8");
-        const exports = [];
-        const isReact = /\b(React|jsx?|tsx?)\b/.test(content) ||
-            filePath.endsWith(".tsx") ||
-            filePath.endsWith(".jsx");
-        const isTypeScript = filePath.endsWith(".ts") || filePath.endsWith(".tsx");
-        // Extract named exports
-        const exportMatches = content.match(/export\s+(?:const|function|class|let|var)\s+(\w+)/g);
-        if (exportMatches) {
-            exportMatches.forEach((match) => {
-                const nameMatch = match.match(/(?:const|function|class|let|var)\s+(\w+)/);
-                if (nameMatch && nameMatch[1] && !exports.includes(nameMatch[1])) {
-                    exports.push(nameMatch[1]);
-                }
-            });
-        }
-        // Extract default export if no named exports found
-        if (exports.length === 0 && /export\s+default/.test(content)) {
-            const fileName = filePath
-                .split("/")
-                .pop()
-                ?.replace(/\.(ts|tsx|js|jsx)$/, "") || "Component";
-            exports.push(fileName.charAt(0).toUpperCase() + fileName.slice(1));
-        }
-        return { exports, isReact, isTypeScript };
-    }
-    catch (error) {
-        frameworkLogger.log("test-template-generator", "analyze-file", "error", { error, message: `Error analyzing ${filePath}:` });
-        return { exports: [], isReact: false, isTypeScript: false };
-    }
-}

package/dist/utils/token-manager.d.ts

@@ -1,48 +0,0 @@
-export interface TokenLimits {
-    maxPromptTokens: number;
-    warningThreshold: number;
-    modelLimits: Record<string, number>;
-}
-export interface ContextPruningConfig {
-    enabled: boolean;
-    aggressivePruning: boolean;
-    preserveCriticalContext: boolean;
-}
-export declare class TokenManager {
-    private config;
-    constructor(configPath?: string);
-    private loadConfig;
-    /**
-     * Estimate token count for text (rough approximation)
-     * Uses 4 characters per token as a conservative estimate
-     */
-    estimateTokens(text: string): number;
-    /**
-     * Check if prompt exceeds limits
-     */
-    checkLimits(prompt: string, modelName?: string): {
-        withinLimit: boolean;
-        currentTokens: number;
-        maxTokens: number;
-        needsPruning: boolean;
-        warning: boolean;
-    };
-    /**
-     * Prune context to fit within token limits
-     */
-    pruneContext(context: string, targetTokens?: number): string;
-    private extractCriticalSections;
-    private extractSection;
-    private extractNonCriticalContent;
-    private pruneNonCriticalContent;
-    /**
-     * Generate warning message for token limits
-     */
-    generateWarning(limitCheck: ReturnType<TokenManager["checkLimits"]>): string;
-    /**
-     * Get current configuration
-     */
-    getConfig(): TokenLimits & {
-        contextPruning: ContextPruningConfig;
-    };
-}