0xray 4.0.13 → 4.0.14

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

@@ -0,0 +1,341 @@
+/**
+ * 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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,87 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,155 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,46 @@
+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;
+}