0xray 3.0.12 → 3.1.0

package/dist/skills/testing-best-practices/SKILL.md

@@ -0,0 +1,37 @@
+---
+source: framework
+name: testing-best-practices
+description: Testing best practices and quality assurance
+author: StrRay Framework
+version: 1.0.0
+schema_version: "1.0"
+tags: [testing, testing, best, practices]
+capabilities:
+  - write_unit_tests
+  - write_integration_tests
+  - analyze_coverage
+dependencies: []
+
+mcp:
+  testing-best-practices:
+    command: node
+    args: [node_modules/0xray/dist/mcps/knowledge-skills/testing-best-practices.server.js]
+---
+
+# Testing Best Practices Skill
+
+Testing best practices and quality assurance.
+
+## Tools Available
+
+- **testing_practices**: Testing practices
+- **quality_assurance**: Quality assurance
+- **best_practices**: Best practices
+
+## Usage
+
+This skill provides testing capabilities for testing best practices functionality.
+
+## Integration
+
+Activated when testing capabilities are requested through the skills system.

package/dist/skills/xray-orchestrator/index.js

@@ -222,4 +222,3 @@ function formatUptime(ms) {
 }
 // Export for OpenClaw
 export default { handleSkill };
-//# sourceMappingURL=index.js.map

package/dist/state/context-providers.js

@@ -0,0 +1 @@
+export {};

package/dist/state/index.js

@@ -1,3 +1,8 @@
 // 0xRay Framework State Management
-export { XrayStateManager, XrayStateManager as StrRayStateManager } from "./state-manager.js";
-//# sourceMappingURL=index.js.map
+// Export all state management utilities and providers
+export * from "./state-manager.js";
+export * from "./context-providers.js";
+export * from "./state-types.js";
+// Re-export commonly used state utilities
+export { XrayStateManager } from "./state-manager.js";
+export { XrayStateManager as StringRayStateManager } from "./state-manager.js";

package/dist/state/state-manager.js

@@ -204,6 +204,5 @@ export class XrayStateManager {
         return conflict.value2; // Prefer the second value as newer
     }
 }
-// Keep StrRayStateManager for internal backward compat
-export { XrayStateManager as StrRayStateManager };
-//# sourceMappingURL=state-manager.js.map
+// Export alias for scripts expecting StrRayStateManager (backward compatibility)
+export { XrayStateManager as StringRayStateManager };

package/dist/state/state-types.js

@@ -0,0 +1 @@
+export {};

package/dist/testing/memory-regression-suite.js

@@ -0,0 +1,258 @@
+import { EventEmitter } from "events";
+export class MemoryRegressionTester extends EventEmitter {
+    config;
+    tests = [];
+    constructor(config = {}) {
+        super();
+        this.config = {
+            testTimeout: 30000, // 30 seconds
+            memorySamplingInterval: 1000, // 1 second
+            acceptableMemoryGrowth: 10, // 10MB
+            leakDetectionThreshold: 1, // 1MB per minute
+            ...config,
+        };
+    }
+    /**
+     * Add a regression test
+     */
+    addTest(test) {
+        this.tests.push(test);
+    }
+    /**
+     * Run all regression tests
+     */
+    async runAllTests() {
+        const results = [];
+        for (const test of this.tests) {
+            try {
+                const result = await this.runTest(test);
+                results.push(result);
+            }
+            catch (error) {
+                results.push({
+                    testName: test.name,
+                    passed: false,
+                    memoryDelta: 0,
+                    leakRate: 0,
+                    duration: 0,
+                    error: error instanceof Error ? error.message : String(error),
+                    recommendations: [
+                        "Check test implementation",
+                        "Verify memory cleanup",
+                    ],
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Run a single regression test
+     */
+    async runTest(test) {
+        const startTime = Date.now();
+        try {
+            // Setup
+            if (test.setup) {
+                await Promise.resolve(test.setup());
+            }
+            // Memory sampling during test
+            const samples = [];
+            const samplingInterval = setInterval(() => {
+                const memUsage = process.memoryUsage();
+                samples.push(memUsage.heapUsed);
+            }, this.config.memorySamplingInterval);
+            // Execute test with timeout
+            const testPromise = test.execute();
+            const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Test timeout")), this.config.testTimeout));
+            await Promise.race([testPromise, timeoutPromise]);
+            clearInterval(samplingInterval);
+            // Calculate results
+            const endTime = Date.now();
+            const duration = endTime - startTime;
+            if (samples.length === 0) {
+                throw new Error("No memory samples collected");
+            }
+            const startMemory = samples[0];
+            const endMemory = samples[samples.length - 1];
+            const memoryDelta = (endMemory - startMemory) / 1024 / 1024; // MB
+            // Calculate leak rate (MB per minute)
+            const leakRate = duration > 0 ? memoryDelta / (duration / 1000 / 60) : 0;
+            // Determine pass/fail
+            const passed = Math.abs(memoryDelta) <= test.expectedMemoryDelta.maxIncrease &&
+                Math.abs(leakRate) <= test.expectedMemoryDelta.acceptableLeak;
+            // Generate recommendations
+            const recommendations = [];
+            if (memoryDelta > test.expectedMemoryDelta.maxIncrease) {
+                recommendations.push(`Memory increased by ${memoryDelta.toFixed(2)}MB (expected ≤${test.expectedMemoryDelta.maxIncrease}MB)`);
+            }
+            if (leakRate > test.expectedMemoryDelta.acceptableLeak) {
+                recommendations.push(`Memory leak rate: ${leakRate.toFixed(2)}MB/min (expected ≤${test.expectedMemoryDelta.acceptableLeak}MB/min)`);
+            }
+            if (samples.length > 10) {
+                const variance = this.calculateVariance(samples);
+                if (variance > 5 * 1024 * 1024) {
+                    // 5MB variance
+                    recommendations.push("High memory variance detected - consider stabilizing allocations");
+                }
+            }
+            // Cleanup
+            if (test.cleanup) {
+                await Promise.resolve(test.cleanup());
+            }
+            return {
+                testName: test.name,
+                passed,
+                memoryDelta,
+                leakRate,
+                duration,
+                recommendations,
+            };
+        }
+        catch (error) {
+            // Cleanup on error
+            if (test.cleanup) {
+                try {
+                    await test.cleanup();
+                }
+                catch (cleanupError) {
+                    // Ignore cleanup errors
+                }
+            }
+            throw error;
+        }
+    }
+    /**
+     * Create a standard memory regression test
+     */
+    createStandardTest(name, description, testFunction, options = {}) {
+        return {
+            name,
+            description,
+            setup: options.setup,
+            execute: testFunction,
+            cleanup: options.cleanup,
+            expectedMemoryDelta: {
+                maxIncrease: options.maxMemoryIncrease || this.config.acceptableMemoryGrowth,
+                acceptableLeak: options.acceptableLeakRate || this.config.leakDetectionThreshold,
+            },
+        };
+    }
+    /**
+     * Generate test report
+     */
+    generateReport(results) {
+        const passed = results.filter((r) => r.passed).length;
+        const failed = results.length - passed;
+        let report = `# Memory Regression Test Report\n\n`;
+        report += `**Summary:** ${passed}/${results.length} tests passed (${failed} failed)\n\n`;
+        if (failed > 0) {
+            report += `## Failed Tests\n\n`;
+            results
+                .filter((r) => !r.passed)
+                .forEach((result) => {
+                report += `### ${result.testName}\n`;
+                report += `- Memory Delta: ${result.memoryDelta.toFixed(2)}MB\n`;
+                report += `- Leak Rate: ${result.leakRate.toFixed(2)}MB/min\n`;
+                report += `- Duration: ${result.duration}ms\n`;
+                if (result.error) {
+                    report += `- Error: ${result.error}\n`;
+                }
+                if (result.recommendations.length > 0) {
+                    report += `- Recommendations:\n`;
+                    result.recommendations.forEach((rec) => {
+                        report += `  - ${rec}\n`;
+                    });
+                }
+                report += `\n`;
+            });
+        }
+        report += `## Performance Metrics\n\n`;
+        const avgDelta = results.reduce((sum, r) => sum + r.memoryDelta, 0) / results.length;
+        const avgLeakRate = results.reduce((sum, r) => sum + r.leakRate, 0) / results.length;
+        const totalDuration = results.reduce((sum, r) => sum + r.duration, 0);
+        report += `- Average Memory Delta: ${avgDelta.toFixed(2)}MB\n`;
+        report += `- Average Leak Rate: ${avgLeakRate.toFixed(2)}MB/min\n`;
+        report += `- Total Test Duration: ${totalDuration}ms\n`;
+        return report;
+    }
+    /**
+     * Calculate variance of memory samples
+     */
+    calculateVariance(samples) {
+        const mean = samples.reduce((sum, s) => sum + s, 0) / samples.length;
+        const variance = samples.reduce((sum, s) => sum + Math.pow(s - mean, 2), 0) /
+            samples.length;
+        return variance;
+    }
+}
+// Pre-configured test templates
+export const memoryTestTemplates = {
+    sessionOperations: (sessionCount = 100) => ({
+        name: "Session Operations Memory Test",
+        description: `Test memory usage during ${sessionCount} session operations`,
+        setup: async () => {
+            // Setup would initialize session manager
+        },
+        execute: async () => {
+            // Simulate session operations
+            const operations = [];
+            for (let i = 0; i < sessionCount; i++) {
+                operations.push({
+                    id: `session-${i}`,
+                    data: { userId: i, metadata: { created: Date.now(), active: true } },
+                });
+            }
+            return operations;
+        },
+        cleanup: async () => {
+            // Cleanup sessions
+        },
+        expectedMemoryDelta: {
+            maxIncrease: sessionCount * 0.01, // ~10KB per session
+            acceptableLeak: 0.1, // 0.1MB per minute
+        },
+    }),
+    cacheOperations: (cacheSize = 1000) => ({
+        name: "Cache Operations Memory Test",
+        description: `Test memory usage during ${cacheSize} cache operations`,
+        execute: async () => {
+            const cache = new Map();
+            for (let i = 0; i < cacheSize; i++) {
+                cache.set(`key-${i}`, {
+                    data: `value-${i}`.repeat(10), // ~100 bytes per entry
+                    timestamp: Date.now(),
+                });
+            }
+            // Simulate cache operations
+            for (let i = 0; i < cacheSize / 2; i++) {
+                cache.get(`key-${i}`);
+            }
+            return cache.size;
+        },
+        expectedMemoryDelta: {
+            maxIncrease: (cacheSize * 0.1) / 1024 / 1024, // ~100KB total
+            acceptableLeak: 0.05, // 0.05MB per minute
+        },
+    }),
+    streamingOperations: (messageCount = 1000) => ({
+        name: "Streaming Operations Memory Test",
+        description: `Test memory usage during ${messageCount} streaming operations`,
+        execute: async () => {
+            const messages = [];
+            for (let i = 0; i < messageCount; i++) {
+                messages.push({
+                    id: i,
+                    payload: Buffer.from(`message-${i}-`.repeat(50)), // ~500 bytes per message
+                    timestamp: Date.now(),
+                });
+                // Simulate processing delay
+                await new Promise((resolve) => setTimeout(resolve, 1));
+            }
+            return messages.length;
+        },
+        expectedMemoryDelta: {
+            maxIncrease: (messageCount * 0.5) / 1024 / 1024, // ~500KB total
+            acceptableLeak: 0.2, // 0.2MB per minute
+        },
+    }),
+};

package/dist/tools/assess-complexity-tool.js

@@ -42,4 +42,3 @@ export function shouldDelegate(input) {
 export function getDelegationStrategy(input) {
     return assessComplexity(input);
 }
-//# sourceMappingURL=assess-complexity-tool.js.map

package/dist/tools/query-routing-tool.js

@@ -57,4 +57,3 @@ export function listAllRoutes() {
     unique.sort((a, b) => b.confidence - a.confidence);
     return unique;
 }
-//# sourceMappingURL=query-routing-tool.js.map

package/dist/types/metamorphosis.js

@@ -4,4 +4,3 @@
  * Extracted from postprocessor/metamorphosis/ for neutral access by kernel.
  */
 export {};
-//# sourceMappingURL=metamorphosis.js.map

package/dist/utils/batch-operations.js

@@ -0,0 +1,292 @@
+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/codex-parser.js

@@ -443,4 +443,3 @@ export async function validateBeforeModification(content, filePath) {
         warnings,
     };
 }
-//# sourceMappingURL=codex-parser.js.map

package/dist/utils/command-runner.js

@@ -94,4 +94,3 @@ export async function runCommandSafeStrict(command, args, options = {}) {
     }
     return result.stdout;
 }
-//# sourceMappingURL=command-runner.js.map

package/dist/utils/import-resolver.js

@@ -77,7 +77,7 @@ export class ImportResolver {
     detectInstalled() {
         return (this.currentDir.includes("/node_modules/") ||
             this.currentDir.includes("\\node_modules\\") ||
-            (this.currentDir.includes("xray") &&
+            (this.currentDir.includes("strray") &&
                 !this.currentDir.includes(this.projectRoot)));
     }
     detectTesting() {
@@ -187,4 +187,3 @@ export class ImportResolver {
     }
 }
 export const importResolver = ImportResolver.getInstance();
-//# sourceMappingURL=import-resolver.js.map

package/dist/utils/language-detector.js

@@ -381,4 +381,3 @@ export const languageDetector = {
     getTestFilePath,
     buildTestCommand,
 };
-//# sourceMappingURL=language-detector.js.map