0xray 2.1.4 → 2.2.0

package/dist/performance/performance-regression-tester.js

@@ -1,342 +0,0 @@
-/**
- * Performance Regression Testing
- *
- * Automated testing system that detects performance regressions and
- * enforces performance budget compliance in CI/CD pipelines.
- *
- * @version 1.0.0
- * @since 2026-01-08
- */
-import { performance } from "perf_hooks";
-import * as fs from "fs";
-import { frameworkLogger } from "../core/framework-logger.js";
-import { PerformanceBudgetEnforcer, PERFORMANCE_BUDGET, } from "./performance-budget-enforcer.js";
-/**
- * Performance regression testing system
- */
-export class PerformanceRegressionTester {
-    baselines = new Map();
-    results = [];
-    budgetEnforcer;
-    constructor(budgetEnforcer) {
-        this.budgetEnforcer = budgetEnforcer || new PerformanceBudgetEnforcer();
-    }
-    /**
-     * Load performance baselines from file
-     */
-    loadBaselines(baselineFile) {
-        try {
-            if (fs.existsSync(baselineFile)) {
-                const data = fs.readFileSync(baselineFile, "utf8");
-                const baselines = JSON.parse(data);
-                this.baselines = new Map(Object.entries(baselines));
-            }
-            else {
-                // No existing baselines found, will use defaults
-            }
-        }
-        catch (error) {
-            frameworkLogger.log("performance-regression-tester", "baseline-load-failed", "error", { file: baselineFile, error });
-        }
-    }
-    /**
-     * Save performance baselines to file
-     */
-    saveBaselines(baselineFile) {
-        try {
-            const baselines = Object.fromEntries(this.baselines);
-            fs.writeFileSync(baselineFile, JSON.stringify(baselines, null, 2));
-        }
-        catch (error) {
-            frameworkLogger.log("performance-regression-tester", "baseline-save-failed", "error", { file: baselineFile, error });
-        }
-    }
-    /**
-     * Run a single performance regression test
-     */
-    async runRegressionTest(test) {
-        const startTime = performance.now();
-        try {
-            // Set timeout for the test
-            const timeoutPromise = new Promise((_, reject) => {
-                setTimeout(() => reject(new Error(`Test timeout after ${test.timeout}ms`)), test.timeout);
-            });
-            const testPromise = Promise.resolve(test.testFunction());
-            await Promise.race([testPromise, timeoutPromise]);
-            const duration = performance.now() - startTime;
-            const baseline = this.baselines.get(test.name);
-            let deviation = 0;
-            let status = "pass";
-            if (baseline) {
-                deviation =
-                    ((duration - baseline.averageDuration) / baseline.averageDuration) *
-                        100;
-                if (Math.abs(deviation) > test.tolerance) {
-                    if (Math.abs(deviation) > test.tolerance * 2) {
-                        status = "fail";
-                    }
-                    else {
-                        status = "warning";
-                    }
-                }
-            }
-            else {
-                // No baseline, create one
-                deviation = 0;
-                status = "pass";
-            }
-            const expectedDuration = baseline
-                ? baseline.averageDuration
-                : test.expectedDuration || duration;
-            const result = {
-                testName: test.name,
-                duration,
-                expectedDuration,
-                deviation,
-                status,
-                timestamp: Date.now(),
-            };
-            this.results.push(result);
-            return result;
-        }
-        catch (error) {
-            const duration = performance.now() - startTime;
-            const result = {
-                testName: test.name,
-                duration,
-                deviation: 0,
-                status: "fail",
-                error: error instanceof Error ? error.message : String(error),
-                timestamp: Date.now(),
-            };
-            this.results.push(result);
-            return result;
-        }
-    }
-    /**
-     * Run a complete regression test suite
-     */
-    async runTestSuite(suite) {
-        // Load baselines
-        this.loadBaselines(suite.baselineFile);
-        const suiteStartTime = performance.now();
-        const results = [];
-        // Run all tests
-        for (const test of suite.tests) {
-            const result = await this.runRegressionTest(test);
-            results.push(result);
-            const statusIcon = result.status === "pass"
-                ? "✅"
-                : result.status === "warning"
-                    ? "⚠️"
-                    : "❌";
-            const durationStr = result.duration.toFixed(2);
-            const deviationStr = result.deviation.toFixed(2);
-            const expectedStr = result.expectedDuration
-                ? result.expectedDuration.toFixed(2)
-                : "N/A";
-            if (result.error) {
-                frameworkLogger.log("performance-regression-tester", "test-failed", "error", { testName: result.testName, error: result.error });
-            }
-        }
-        // Update baselines with new results
-        this.updateBaselines(results);
-        // Generate performance budget report
-        let budgetReport;
-        try {
-            budgetReport = await this.budgetEnforcer.generatePerformanceReport();
-        }
-        catch (error) {
-            frameworkLogger.log("performance-regression-tester", "budget-report-failed", "error", { error });
-        }
-        const suiteDuration = performance.now() - suiteStartTime;
-        const summary = this.generateSummary(results, suiteDuration);
-        // Display summary
-        // Test failure count - kept as console.log for CI visibility
-        if (budgetReport) {
-            if (budgetReport.violations.length > 0) {
-                budgetReport.violations.forEach((v) => { });
-            }
-        }
-        // Save updated baselines
-        this.saveBaselines(suite.baselineFile);
-        // Check if suite should fail
-        const shouldFail = suite.failOnRegression &&
-            (summary.failed > 0 ||
-                (budgetReport && budgetReport.overallStatus === "fail"));
-        if (shouldFail) {
-            throw new Error("Performance regression test suite failed");
-        }
-        else {
-            frameworkLogger.log("performance-regression-tester", "suite-passed", "info", { message: "Performance regression test suite passed" });
-        }
-        const result = {
-            results,
-            summary,
-            success: !shouldFail,
-        };
-        if (budgetReport) {
-            result.budgetReport = budgetReport;
-        }
-        return result;
-    }
-    /**
-     * Update baselines with new test results
-     */
-    updateBaselines(results) {
-        for (const result of results) {
-            if (result.status === "pass" || result.status === "warning") {
-                const existing = this.baselines.get(result.testName);
-                if (existing) {
-                    // Update rolling average
-                    const newCount = existing.sampleCount + 1;
-                    const newAverage = (existing.averageDuration * existing.sampleCount +
-                        result.duration) /
-                        newCount;
-                    // Update standard deviation (simplified)
-                    const variance = Math.pow(result.duration - existing.averageDuration, 2);
-                    const newStdDev = Math.sqrt((existing.standardDeviation *
-                        existing.standardDeviation *
-                        existing.sampleCount +
-                        variance) /
-                        newCount);
-                    this.baselines.set(result.testName, {
-                        ...existing,
-                        averageDuration: newAverage,
-                        standardDeviation: newStdDev,
-                        sampleCount: newCount,
-                        lastUpdated: Date.now(),
-                    });
-                }
-                else {
-                    // Create new baseline
-                    this.baselines.set(result.testName, {
-                        testName: result.testName,
-                        averageDuration: result.duration,
-                        standardDeviation: 0,
-                        sampleCount: 1,
-                        lastUpdated: Date.now(),
-                        tolerance: 10, // Default 10% tolerance
-                    });
-                }
-            }
-        }
-    }
-    /**
-     * Generate test suite summary
-     */
-    generateSummary(results, suiteDuration) {
-        const passed = results.filter((r) => r.status === "pass").length;
-        const warnings = results.filter((r) => r.status === "warning").length;
-        const failed = results.filter((r) => r.status === "fail").length;
-        const deviations = results.map((r) => Math.abs(r.deviation));
-        const averageDeviation = deviations.length > 0
-            ? deviations.reduce((a, b) => a + b, 0) / deviations.length
-            : 0;
-        const maxDeviation = deviations.length > 0 ? Math.max(...deviations) : 0;
-        return {
-            totalTests: results.length,
-            passed,
-            warnings,
-            failed,
-            averageDeviation,
-            maxDeviation,
-            duration: suiteDuration,
-        };
-    }
-    /**
-     * Create default performance regression test suite
-     */
-    createDefaultTestSuite() {
-        const tests = [
-            {
-                name: "bundle-size-analysis",
-                description: "Analyze bundle size against performance budget",
-                testFunction: async () => {
-                    await this.budgetEnforcer.analyzeBundleSize();
-                },
-                timeout: 10000,
-                tolerance: 5,
-            },
-            {
-                name: "module-import-performance",
-                description: "Measure core module import performance",
-                testFunction: async () => {
-                    const start = performance.now();
-                    await import("../core/index");
-                    const duration = performance.now() - start;
-                    if (duration > PERFORMANCE_BUDGET.runtime.startupTime) {
-                        throw new Error(`Import time ${duration.toFixed(2)}ms exceeds budget of ${PERFORMANCE_BUDGET.runtime.startupTime}ms`);
-                    }
-                },
-                timeout: 5000,
-                tolerance: 10,
-            },
-            {
-                name: "memory-usage-check",
-                description: "Verify memory usage stays within budget",
-                testFunction: () => {
-                    const memUsage = process.memoryUsage();
-                    if (memUsage.heapUsed > PERFORMANCE_BUDGET.runtime.memoryUsage) {
-                        throw new Error(`Heap usage ${(memUsage.heapUsed / 1024 / 1024).toFixed(2)}MB exceeds budget of ${(PERFORMANCE_BUDGET.runtime.memoryUsage / 1024 / 1024).toFixed(2)}MB`);
-                    }
-                },
-                timeout: 1000,
-                tolerance: 5,
-            },
-            {
-                name: "test-execution-performance",
-                description: "Measure simple test execution time",
-                testFunction: async () => {
-                    const start = performance.now();
-                    // Simple test operation instead of running npm test
-                    const testArray = Array.from({ length: 1000 }, (_, i) => i * i);
-                    const result = testArray.reduce((sum, val) => sum + val, 0);
-                    if (result < 0)
-                        throw new Error("Unexpected result"); // Never happens
-                    const duration = performance.now() - start;
-                    // Just ensure the operation completes in reasonable time
-                    if (duration > 100) {
-                        throw new Error(`Test operation ${duration.toFixed(2)}ms too slow`);
-                    }
-                },
-                timeout: 5000,
-                tolerance: 20,
-            },
-        ];
-        return {
-            name: "0xRay Performance Regression Suite",
-            description: "Comprehensive performance regression tests for 0xRay Framework",
-            tests,
-            baselineFile: "./performance-baselines.json",
-            failOnRegression: true,
-            warningThreshold: 10,
-            failureThreshold: 20,
-        };
-    }
-    /**
-     * Export test results for analysis
-     */
-    exportResults() {
-        const summary = {
-            totalTests: this.results.length,
-            passRate: this.results.length > 0
-                ? (this.results.filter((r) => r.status === "pass").length /
-                    this.results.length) *
-                    100
-                : 0,
-            averageDeviation: this.results.length > 0
-                ? this.results.reduce((sum, r) => sum + Math.abs(r.deviation), 0) /
-                    this.results.length
-                : 0,
-            regressionDetected: this.results.some((r) => r.status === "fail"),
-        };
-        return {
-            results: this.results,
-            baselines: Object.fromEntries(this.baselines),
-            summary,
-        };
-    }
-}
-// Export singleton instance
-export const performanceRegressionTester = new PerformanceRegressionTester();

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

@@ -1,37 +0,0 @@
----
-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/state/context-providers.d.ts

@@ -1,4 +0,0 @@
-export interface ContextProviders {
-    createProvider: <T>(value: T) => unknown;
-    useContext: <T>() => T;
-}

package/dist/state/context-providers.js

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

package/dist/state/state-types.d.ts

@@ -1,5 +0,0 @@
-export type StateValue = string | number | boolean | object | null;
-export interface StateTypes {
-    value: StateValue;
-    timestamp: number;
-}

package/dist/state/state-types.js

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

package/dist/utils/batch-operations.d.ts

@@ -1,25 +0,0 @@
-export interface ReplacementOperation {
-    pattern: string;
-    replacement: string;
-    isRegex?: boolean;
-    caseSensitive?: boolean;
-}
-export interface BatchResult {
-    success: boolean;
-    filesModified: number;
-    errors: Array<{
-        file: string;
-        error: string;
-    }>;
-    duration: number;
-}
-export interface FileOperation {
-    filePath: string;
-    operation: "replace" | "append" | "prepend" | "delete";
-    content?: string;
-    pattern?: string;
-}
-export declare function batchReplace(files: string[], operations: ReplacementOperation[]): Promise<BatchResult>;
-export declare function batchFileOperations(operations: FileOperation[]): Promise<BatchResult>;
-export declare function findFilesWithPattern(directory: string, pattern: string, extensions?: string[]): string[];
-export declare function bulkRename(directory: string, oldName: string, newName: string, extensions?: string[]): Promise<BatchResult>;