0xray 4.0.34 → 4.0.35

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/task-graph.d.ts

@@ -1,29 +0,0 @@
-/**
- * Task graph utilities — pure functions for dependency resolution,
- * topological sorting, and conflict resolution.
- *
- * Extracted from KernelOrchestrator for neutral access.
- */
-import type { TaskDefinition } from "../agents/types.js";
-/**
- * DFS-based topological sort with circular dependency detection.
- */
-export declare function topologicalSort(tasks: TaskDefinition[]): TaskDefinition[];
-/**
- * Validates that all task dependencies are within the current task batch.
- * Throws a descriptive error listing cross-orchestrator dependencies.
- */
-export declare function validateTaskDependencies(tasks: TaskDefinition[]): void;
-export interface ConflictInput {
-    response?: unknown;
-    proposed?: unknown;
-    expertiseScore?: number;
-}
-export interface ConflictResult {
-    response: string;
-    expertiseScore: number;
-}
-/**
- * Resolve conflicts by majority vote or highest expertise score.
- */
-export declare function resolveConflicts(conflicts: ConflictInput[], strategy?: "majority_vote" | "expert_priority"): ConflictResult;

package/dist/utils/task-graph.js

@@ -1,106 +0,0 @@
-/**
- * Task graph utilities — pure functions for dependency resolution,
- * topological sorting, and conflict resolution.
- *
- * Extracted from KernelOrchestrator for neutral access.
- */
-/**
- * DFS-based topological sort with circular dependency detection.
- */
-export function topologicalSort(tasks) {
-    const visited = new Set();
-    const visiting = new Set();
-    const result = [];
-    const visit = (taskId) => {
-        if (visiting.has(taskId)) {
-            throw new Error(`Circular dependency detected: ${taskId}`);
-        }
-        if (visited.has(taskId)) {
-            return;
-        }
-        visiting.add(taskId);
-        const task = tasks.find((t) => t.id === taskId);
-        if (task && task.dependencies) {
-            for (const dep of task.dependencies) {
-                visit(dep);
-            }
-        }
-        visiting.delete(taskId);
-        visited.add(taskId);
-        if (task) {
-            result.push(task);
-        }
-    };
-    for (const task of tasks) {
-        if (!visited.has(task.id)) {
-            visit(task.id);
-        }
-    }
-    return result;
-}
-/**
- * Validates that all task dependencies are within the current task batch.
- * Throws a descriptive error listing cross-orchestrator dependencies.
- */
-export function validateTaskDependencies(tasks) {
-    const taskIds = new Set(tasks.map((t) => t.id));
-    const errors = [];
-    for (const task of tasks) {
-        if (task.dependencies && task.dependencies.length > 0) {
-            for (const dep of task.dependencies) {
-                if (!taskIds.has(dep)) {
-                    errors.push(`Task "${task.id}" depends on "${dep}" which is NOT in this orchestrator's task batch.\n` +
-                        `Available tasks in this batch: ${Array.from(taskIds).join(", ")}`);
-                }
-            }
-        }
-    }
-    if (errors.length > 0) {
-        const errorMessage = `[TEST ARCHITECTURE ERROR] Cross-orchestrator dependencies detected.\n\n` +
-            `${errors.join("\n\n")}\n\n` +
-            `This usually means:\n` +
-            `1. You're creating multiple orchestrator instances in one test\n` +
-            `2. Task dependencies are crossing orchestrator boundaries\n\n` +
-            `FIX: Either:\n` +
-            `A) Include the missing dependency task in this executeComplexTask() call\n` +
-            `B) Use a single orchestrator for all dependent tasks\n` +
-            `C) Remove the dependency if it's not needed\n\n` +
-            `Example of correct usage:\n` +
-            `  const orch = new XrayOrchestrator();\n` +
-            `  await orch.executeComplexTask("test", [\n` +
-            `    { id: "task-1" },\n` +
-            `    { id: "task-2", dependencies: ["task-1"] }  // Same orchestrator\n` +
-            `  ]);`;
-        throw new Error(errorMessage);
-    }
-}
-/**
- * Resolve conflicts by majority vote or highest expertise score.
- */
-export function resolveConflicts(conflicts, strategy) {
-    if (conflicts.length === 0) {
-        return { response: "", expertiseScore: 0 };
-    }
-    if (strategy === "majority_vote") {
-        const votes = {};
-        conflicts.forEach((conflict) => {
-            const response = String(conflict.response ?? conflict.proposed ?? "");
-            votes[response] = (votes[response] || 0) + 1;
-        });
-        const maxVotes = Math.max(...Object.values(votes));
-        const winner = Object.entries(votes).find(([_, voteCount]) => voteCount === maxVotes);
-        if (winner) {
-            const winningConflicts = conflicts.filter((c) => String(c.response ?? c.proposed ?? "") === winner[0]);
-            const avgExpertise = winningConflicts.reduce((sum, c) => sum + (c.expertiseScore || 0), 0) / winningConflicts.length;
-            return { response: winner[0], expertiseScore: avgExpertise };
-        }
-    }
-    // Fallback to highest expertise score
-    const bestConflict = conflicts.reduce((best, current) => (current.expertiseScore || 0) > (best.expertiseScore || 0)
-        ? current
-        : best);
-    return {
-        response: String(bestConflict.response ?? bestConflict.proposed ?? ""),
-        expertiseScore: bestConflict.expertiseScore || 0,
-    };
-}

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;
-    };
-}