0xray 4.0.12 → 4.0.13

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

@@ -1,341 +0,0 @@
-/**
- * Performance Regression Testing
- *
- * Automated testing system that detects performance regressions and
- * enforces performance budget compliance in CI/CD pipelines.
- *
- * @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/plugin/plugin-codex-context.d.ts

@@ -1,18 +0,0 @@
-export interface CodexContextEntry {
-    id: string;
-    source: string;
-    content: string;
-    priority: "critical" | "high" | "normal" | "low";
-    metadata: {
-        version: string;
-        termCount: number;
-        loadedAt: string;
-    };
-}
-export declare function extractCodexMetadata(content: string): {
-    version: string;
-    termCount: number;
-};
-export declare function createCodexContextEntry(filePath: string, content: string): CodexContextEntry;
-export declare function loadCodexContext(directory: string): Promise<CodexContextEntry[]>;
-export declare function formatCodexContext(contexts: CodexContextEntry[]): string;

package/dist/plugin/plugin-codex-context.js

@@ -1,87 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { resolveCodexPath } from "./plugin-modules.js";
-import { PluginLogger } from "./plugin-logger.js";
-let cachedCodexContexts = null;
-async function getCodexFileLocations(directory) {
-    const root = directory || process.cwd();
-    const resolved = await resolveCodexPath(root);
-    resolved.push(path.join(root, ".opencode", "codex.codex"), path.join(root, ".xray", "agents_template.md"), path.join(root, "AGENTS.md"));
-    return resolved;
-}
-function readFileContent(filePath) {
-    try {
-        return fs.readFileSync(filePath, "utf-8");
-    }
-    catch (error) {
-        const logger = new PluginLogger(process.cwd());
-        logger.error(`Failed to read file ${filePath}`, error);
-        return null;
-    }
-}
-export function extractCodexMetadata(content) {
-    if (content.trim().startsWith("{")) {
-        try {
-            const parsed = JSON.parse(content);
-            const version = parsed.version || "1.6.0";
-            const terms = parsed.terms || {};
-            const termCount = Object.keys(terms).length;
-            return { version, termCount };
-        }
-        catch {
-            // Not valid JSON, try markdown format
-        }
-    }
-    const versionMatch = content.match(/\*\*Version\*\*:\s*(\d+\.\d+\.\d+)/);
-    const version = versionMatch?.[1] ?? "1.6.0";
-    const termMatches = content.match(/####\s*\d+\.\s/g);
-    const termCount = termMatches ? termMatches.length : 0;
-    return { version, termCount };
-}
-export function createCodexContextEntry(filePath, content) {
-    const metadata = extractCodexMetadata(content);
-    return {
-        id: `xray-codex-${path.basename(filePath)}`,
-        source: filePath,
-        content,
-        priority: "critical",
-        metadata: {
-            version: metadata.version,
-            termCount: metadata.termCount,
-            loadedAt: new Date().toISOString(),
-        },
-    };
-}
-export async function loadCodexContext(directory) {
-    if (cachedCodexContexts) {
-        return cachedCodexContexts;
-    }
-    const codexContexts = [];
-    const locations = await getCodexFileLocations(directory);
-    for (const fileLocation of locations) {
-        const fullPath = path.isAbsolute(fileLocation) ? fileLocation : path.join(directory, fileLocation);
-        const content = readFileContent(fullPath);
-        if (content && content.trim().length > 0) {
-            const entry = createCodexContextEntry(fullPath, content);
-            if (entry.metadata.termCount > 0) {
-                codexContexts.push(entry);
-            }
-        }
-    }
-    cachedCodexContexts = codexContexts;
-    if (codexContexts.length === 0) {
-        const { getOrCreateLogger } = await import("./plugin-logger.js");
-        void getOrCreateLogger(directory).then((l) => l.error(`No valid codex files found. Checked: ${locations.join(", ")}`));
-    }
-    return codexContexts;
-}
-export function formatCodexContext(contexts) {
-    if (contexts.length === 0) {
-        return "";
-    }
-    const parts = [];
-    for (const context of contexts) {
-        parts.push(`# 0xRay Codex Context v${context.metadata.version}`, `Source: ${context.source}`, `Terms Loaded: ${context.metadata.termCount}`, `Loaded At: ${context.metadata.loadedAt}`, "", context.content, "", "---", "");
-    }
-    return parts.join("\n");
-}

package/dist/plugin/plugin-helpers.d.ts

@@ -1,23 +0,0 @@
-import type { ToolArguments, PreProcessorResult, ProcessorManagerLike, ProcessorResult } from "./plugin-types.js";
-import type { PluginLogger } from "./plugin-logger.js";
-export declare function spawnPromise(command: string, args: string[], cwd: string): Promise<{
-    stdout: string;
-    stderr: string;
-}>;
-export declare function getFrameworkVersion(): string;
-export declare function getFrameworkIdentity(): string;
-export declare const TOOL_AGENT_MAP: Record<string, {
-    agent: string;
-    skill: string;
-}>;
-export declare function classifyTaskType(tool: string, args?: ToolArguments): string;
-export declare function isWriteEditOperation(tool: string): boolean;
-export declare function isPublishOperation(tool: string): boolean;
-export declare function resolveAgentName(input: {
-    agentType?: string;
-} | undefined): string;
-export declare function registerAllProcessors(pm: ProcessorManagerLike): void;
-export declare function registerAfterPostProcessors(pm: ProcessorManagerLike): void;
-export declare function logPreProcessorResults(results: PreProcessorResult, logger: PluginLogger): void;
-export declare function logPostProcessorResults(results: ProcessorResult[], logger: PluginLogger): void;
-export declare function logTestAutoCreationResult(results: ProcessorResult[], logger: PluginLogger): void;

package/dist/plugin/plugin-helpers.js

@@ -1,155 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { spawn } from "child_process";
-export function spawnPromise(command, args, cwd) {
-    return new Promise((resolve, reject) => {
-        const child = spawn(command, args, {
-            cwd,
-            stdio: ["ignore", "inherit", "pipe"],
-        });
-        let stderr = "";
-        if (child.stderr) {
-            child.stderr.on("data", (data) => {
-                stderr += data.toString();
-            });
-        }
-        child.on("close", (code) => {
-            if (code === 0) {
-                resolve({ stdout: "", stderr });
-            }
-            else {
-                reject(new Error(`Process exited with code ${code}: ${stderr}`));
-            }
-        });
-        child.on("error", (error) => {
-            reject(error);
-        });
-    });
-}
-export function getFrameworkVersion() {
-    try {
-        const packageJsonPath = path.join(process.cwd(), "package.json");
-        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
-        return packageJson.version || "1.4.6";
-    }
-    catch {
-        return "1.4.6";
-    }
-}
-export function getFrameworkIdentity() {
-    const version = getFrameworkVersion();
-    return `0xRay Framework v${version} - AI Orchestration
-
-🔧 Core: architect, code-reviewer, refactorer, testing-lead, strategist
-📚 Codex: 5 Essential Terms (99.6% Error Prevention Target)
-🎯 Goal: Progressive, production-ready development workflow
-
-📖 Documentation: config dir (codex, config, agents docs) — resolved via config-paths
-`;
-}
-export const TOOL_AGENT_MAP = {
-    write: { agent: "code-reviewer", skill: "write" },
-    edit: { agent: "code-reviewer", skill: "edit" },
-    multiedit: { agent: "code-reviewer", skill: "multiedit" },
-    bash: { agent: "testing-lead", skill: "execution" },
-    search: { agent: "researcher", skill: "search" },
-    read: { agent: "researcher", skill: "read" },
-    glob: { agent: "researcher", skill: "glob" },
-    grep: { agent: "researcher", skill: "search" },
-    ls: { agent: "researcher", skill: "list" },
-};
-export function classifyTaskType(tool, args) {
-    const cmd = String(args?.command ?? "").toLowerCase().trim();
-    if (tool === "bash" && cmd) {
-        if (/(npm|yarn|pnpm)\s+test|jest|vitest|mocha|pytest/.test(cmd))
-            return "testing";
-        if (/(npm|yarn|pnpm)\s+run|npx|cargo|go run|make\s/.test(cmd))
-            return "build";
-        if (/audit|security|snyk|owasp|bandit/.test(cmd))
-            return "security";
-        if (/eslint|prettier|black|ruff|lint|format/.test(cmd))
-            return "lint";
-        if (/git\s/.test(cmd))
-            return "git";
-        if (/(npm|yarn|pnpm)\s+install|pip install|cargo add/.test(cmd))
-            return "install";
-        if (/grep|rg |find |ls |cat |head |tail /.test(cmd))
-            return "search";
-    }
-    if (tool === "write")
-        return "write";
-    if (tool === "edit" || tool === "multiedit")
-        return "edit";
-    if (tool === "read")
-        return "read";
-    if (tool === "search" || tool === "grep" || tool === "glob")
-        return "search";
-    return "unknown";
-}
-export function isWriteEditOperation(tool) {
-    return tool === "write" || tool === "edit" || tool === "multiedit";
-}
-export function isPublishOperation(tool) {
-    return tool === "publish" || tool === "release" || tool === "npm-publish" || tool === "xray-release";
-}
-export function resolveAgentName(input) {
-    const globalAgent = globalThis.currentAgent;
-    if (globalAgent?.agentType)
-        return globalAgent.agentType;
-    if (globalAgent?.type)
-        return globalAgent.type;
-    if (input?.agentType)
-        return input.agentType;
-    return "architect";
-}
-export function registerAllProcessors(pm) {
-    pm.registerProcessor({ name: "preValidate", type: "pre", priority: 10, enabled: true });
-    pm.registerProcessor({ name: "codexCompliance", type: "pre", priority: 20, enabled: true });
-    pm.registerProcessor({ name: "versionCompliance", type: "pre", priority: 25, enabled: true });
-    pm.registerProcessor({ name: "testAutoCreation", type: "post", priority: 5, enabled: true });
-    pm.registerProcessor({ name: "testExecution", type: "post", priority: 10, enabled: true });
-    pm.registerProcessor({ name: "coverageAnalysis", type: "post", priority: 20, enabled: true });
-}
-export function registerAfterPostProcessors(pm) {
-    pm.registerProcessor({ name: "testAutoCreation", type: "post", priority: 50, enabled: true });
-    pm.registerProcessor({ name: "testExecution", type: "post", priority: 10, enabled: true });
-    pm.registerProcessor({ name: "coverageAnalysis", type: "post", priority: 20, enabled: true });
-}
-export function logPreProcessorResults(results, logger) {
-    logger.log(`📊 Pre-processor result: ${results.success ? "SUCCESS" : "FAILED"} (${results.results.length} processors)`);
-    if (!results.success) {
-        const failures = results.results.filter((r) => !r.success);
-        for (const f of failures) {
-            logger.error(`❌ Pre-processor ${f.processorName} failed: ${f.error}`);
-        }
-    }
-    else {
-        for (const r of results.results) {
-            logger.log(`✅ Pre-processor ${r.processorName}: ${r.success ? "OK" : "FAILED"}`);
-        }
-    }
-}
-export function logPostProcessorResults(results, logger) {
-    const allSuccess = results.every((r) => r.success);
-    logger.log(`📊 Post-processor result: ${allSuccess ? "SUCCESS" : "FAILED"} (${results.length} processors)`);
-    for (const r of results) {
-        if (r.success) {
-            logger.log(`✅ Post-processor ${r.processorName}: OK`);
-        }
-        else {
-            logger.error(`❌ Post-processor ${r.processorName} failed: ${r.error}`);
-        }
-    }
-}
-export function logTestAutoCreationResult(results, logger) {
-    const testAutoResult = results.find((r) => r.processorName === "testAutoCreation");
-    if (testAutoResult) {
-        const data = testAutoResult.data;
-        if (testAutoResult.success && data?.testCreated && data?.testFile) {
-            logger.log(`✅ TEST AUTO-CREATION: Created ${data.testFile}`);
-        }
-        else if (!testAutoResult.success) {
-            logger.log(`ℹ️ TEST AUTO-CREATION: ${testAutoResult.error ?? "skipped - no new files"}`);
-        }
-    }
-}

package/dist/plugin/plugin-logger.d.ts

@@ -1,8 +0,0 @@
-export declare class PluginLogger {
-    private logPath;
-    constructor(directory: string);
-    logAsync(message: string): Promise<void>;
-    log(message: string): void;
-    error(message: string, error?: unknown): void;
-}
-export declare function getOrCreateLogger(directory: string): Promise<PluginLogger>;

package/dist/plugin/plugin-logger.js

@@ -1,46 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-export class PluginLogger {
-    logPath;
-    constructor(directory) {
-        const logsDir = path.join(directory, ".opencode", "logs");
-        if (!fs.existsSync(logsDir)) {
-            fs.mkdirSync(logsDir, { recursive: true });
-        }
-        const today = new Date().toISOString().split("T")[0];
-        this.logPath = path.join(logsDir, `xray-plugin-${today}.log`);
-    }
-    async logAsync(message) {
-        try {
-            const timestamp = new Date().toISOString();
-            const logEntry = `[${timestamp}] ${message}\n`;
-            await fs.promises.appendFile(this.logPath, logEntry, "utf-8");
-        }
-        catch {
-            // Silent fail - logging failure should not break plugin
-        }
-    }
-    log(message) {
-        void this.logAsync(message);
-    }
-    error(message, error) {
-        const errorDetail = error instanceof Error ? `: ${error.message}` : "";
-        this.log(`ERROR: ${message}${errorDetail}`);
-    }
-}
-let loggerInstance = null;
-let loggerInitPromise = null;
-export async function getOrCreateLogger(directory) {
-    if (loggerInstance) {
-        return loggerInstance;
-    }
-    if (loggerInitPromise) {
-        return loggerInitPromise;
-    }
-    loggerInitPromise = (async () => {
-        const logger = new PluginLogger(directory);
-        loggerInstance = logger;
-        return logger;
-    })();
-    return loggerInitPromise;
-}