0xray 2.0.0

package/dist/processors/processor-manager.js

@@ -0,0 +1,826 @@
+import { frameworkLogger } from "../core/framework-logger.js";
+import { readdir } from "fs/promises";
+import { join, basename } from "path";
+export class ProcessorManager {
+    processors = new Map();
+    metrics = new Map();
+    stateManager;
+    activeProcessors = new Set();
+    factories = new Map();
+    lastExecutionTime = new Map();
+    constructor(stateManager) {
+        this.stateManager = stateManager;
+        this.registerBuiltInFactories();
+    }
+    registerProcessorInstance(processor) {
+        if (this.factories.has(processor.name)) {
+            return false;
+        }
+        this.factories.set(processor.name, {
+            execute: async (ctx) => {
+                const result = await processor.execute(ctx);
+                return result.data;
+            },
+        });
+        frameworkLogger.log("processor-manager", "auto-discovered-processor", "info", {
+            name: processor.name,
+            type: processor.type,
+            priority: processor.priority,
+        });
+        return true;
+    }
+    async discoverProcessors(directory) {
+        const dir = directory || join(__dirname, "implementations");
+        const discovered = [];
+        let files;
+        try {
+            files = await readdir(dir);
+        }
+        catch {
+            return discovered;
+        }
+        for (const file of files) {
+            const isJs = file.endsWith(".js");
+            const isTs = file.endsWith(".ts");
+            if ((!isJs && !isTs) || file.includes(".test.") || file.includes(".spec.") || file.includes(".d.ts")) {
+                continue;
+            }
+            try {
+                const baseName = basename(file, isJs ? ".js" : ".ts");
+                const modulePath = `./implementations/${baseName}.js`;
+                const mod = await import(modulePath);
+                for (const exportValue of Object.values(mod)) {
+                    if (typeof exportValue === "function" && exportValue.prototype) {
+                        try {
+                            const deps = exportValue.dependencies;
+                            const instance = deps && deps.length > 0
+                                ? this.instantiateWithDeps(exportValue, deps)
+                                : new exportValue();
+                            if (instance &&
+                                typeof instance.name === "string" &&
+                                instance.name.length > 0 &&
+                                (instance.type === "pre" || instance.type === "post") &&
+                                typeof instance.priority === "number" &&
+                                typeof instance.execute === "function") {
+                                this.registerProcessorInstance(instance);
+                                discovered.push(instance.name);
+                            }
+                        }
+                        catch {
+                            // Constructor may require arguments we can't resolve — skip
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                frameworkLogger.log("processor-manager", "discovery-import-failed", "warning", {
+                    file,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        frameworkLogger.log("processor-manager", "processor-discovery-complete", "info", {
+            scanned: files.length,
+            discovered: discovered.length,
+            names: discovered,
+        });
+        return discovered;
+    }
+    instantiateWithDeps(Ctor, deps) {
+        const resolved = [];
+        for (const dep of deps) {
+            if (dep === "stateManager") {
+                resolved.push(this.stateManager);
+            }
+            else {
+                frameworkLogger.log("processor-manager", "unresolved-dependency", "warning", {
+                    dependency: dep,
+                    processor: Ctor.name,
+                });
+                return null;
+            }
+        }
+        return new Ctor(...resolved);
+    }
+    registerBuiltInFactories() {
+        const f = this.factories;
+        f.set("preValidate", {
+            execute: async (ctx) => {
+                const { PreValidateProcessor } = await import("./implementations/pre-validate-processor.js");
+                const p = new PreValidateProcessor();
+                const r = await p.execute(ctx);
+                return r.data;
+            },
+            init: async () => {
+                frameworkLogger.log("processor-manager", "initializing pre-validate processor", "info");
+            },
+        });
+        f.set("codexCompliance", {
+            execute: async (ctx) => {
+                const { CodexComplianceProcessor } = await import("./implementations/codex-compliance-processor.js");
+                const p = new CodexComplianceProcessor();
+                const r = await p.execute(ctx);
+                return r.data;
+            },
+            init: async () => {
+                frameworkLogger.log("processor-manager", "initializing codex compliance processor", "info");
+            },
+        });
+        f.set("logProtection", {
+            execute: async (ctx) => {
+                const { LogProtectionProcessor } = await import("./implementations/log-protection-processor.js");
+                const p = new LogProtectionProcessor();
+                const filePath = ctx.filePath || ctx.toolInput?.args?.filePath;
+                const operation = ctx.operation || ctx.toolInput?.args?.operation;
+                const result = await p.execute({ filePath, operation });
+                return result.data;
+            },
+        });
+        f.set("versionCompliance", {
+            execute: async (ctx) => {
+                const { VersionComplianceProcessor } = await import("./implementations/version-compliance-processor.js");
+                const p = new VersionComplianceProcessor(process.cwd());
+                const result = await p.validateVersionCompliance();
+                return {
+                    success: result.compliant,
+                    errors: result.errors || [],
+                    warnings: result.warnings || [],
+                    checkedAt: new Date().toISOString(),
+                };
+            },
+            init: async () => {
+                frameworkLogger.log("processor-manager", "initializing version compliance processor", "info");
+                try {
+                    const { VersionComplianceProcessor } = await import("./implementations/version-compliance-processor.js");
+                    const p = new VersionComplianceProcessor(process.cwd());
+                    const result = await p.validateVersionCompliance();
+                    if (!result.compliant) {
+                        frameworkLogger.log("processor-manager", "version-compliance", "info", {
+                            message: "Version compliance issues detected - commits may be blocked",
+                            errors: result.errors,
+                            warnings: result.warnings,
+                        });
+                    }
+                    else {
+                        frameworkLogger.log("processor-manager", "version-compliance", "info", {
+                            message: `Version compliance verified: NPM ${result.npmVersion}, UVM ${result.uvmVersion}`,
+                        });
+                    }
+                }
+                catch (error) {
+                    frameworkLogger.log("processor-manager", "version-compliance-init-error", "error", {
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            },
+        });
+        f.set("errorBoundary", {
+            execute: async (ctx) => {
+                const { ErrorBoundaryProcessor } = await import("./implementations/error-boundary-processor.js");
+                const p = new ErrorBoundaryProcessor();
+                const r = await p.execute(ctx);
+                return r.data;
+            },
+            init: async () => {
+                frameworkLogger.log("processor-manager", "initializing error boundary processor", "info");
+            },
+        });
+        f.set("testExecution", {
+            execute: async (ctx) => {
+                const { TestExecutionProcessor } = await import("./implementations/test-execution-processor.js");
+                const p = new TestExecutionProcessor();
+                const r = await p.execute(ctx);
+                return r.data;
+            },
+            init: async () => {
+                frameworkLogger.log("processor-manager", "initializing test execution processor", "info");
+            },
+        });
+        f.set("regressionTesting", {
+            execute: async (ctx) => {
+                const { RegressionTestingProcessor } = await import("./implementations/regression-testing-processor.js");
+                const p = new RegressionTestingProcessor();
+                const r = await p.execute(ctx);
+                return r.data;
+            },
+            init: async () => {
+                frameworkLogger.log("processor-manager", "initializing regression testing processor", "info");
+            },
+        });
+        f.set("stateValidation", {
+            execute: async (ctx) => {
+                const { StateValidationProcessor } = await import("./implementations/state-validation-processor.js");
+                const p = new StateValidationProcessor(this.stateManager);
+                const r = await p.execute(ctx);
+                return r.data;
+            },
+            init: async () => {
+                frameworkLogger.log("processor-manager", "initializing state validation processor", "info");
+            },
+        });
+        f.set("refactoringLogging", {
+            execute: async (ctx) => {
+                const { RefactoringLoggingProcessorWrapper } = await import("./implementations/refactoring-logging-processor-wrapper.js");
+                const p = new RefactoringLoggingProcessorWrapper();
+                const r = await p.execute(ctx);
+                return r.data;
+            },
+        });
+        f.set("testAutoCreation", {
+            execute: async (ctx) => {
+                const { testAutoCreationProcessor } = await import("./implementations/test-auto-creation-processor.js");
+                const result = await testAutoCreationProcessor.execute(ctx);
+                return { success: result.success, message: result.message, data: result.data };
+            },
+            init: async () => {
+                frameworkLogger.log("processor-manager", "initializing test auto-creation processor", "info");
+            },
+        });
+        f.set("coverageAnalysis", {
+            execute: async (ctx) => {
+                const { CoverageAnalysisProcessor } = await import("./implementations/coverage-analysis-processor.js");
+                const p = new CoverageAnalysisProcessor();
+                const r = await p.execute(ctx);
+                return r.data;
+            },
+        });
+        f.set("agentsMdValidation", {
+            execute: async (ctx) => {
+                const { AgentsMdValidationProcessor } = await import("./implementations/agents-md-validation-processor.js");
+                const p = new AgentsMdValidationProcessor(process.cwd());
+                const result = await p.execute({
+                    tool: ctx.tool || "validate",
+                    operation: ctx.operation || "pre-commit",
+                });
+                return {
+                    success: result.success,
+                    blocked: result.blocked,
+                    message: result.message,
+                    errors: result.result?.errors || [],
+                    warnings: result.result?.warnings || [],
+                    checkedAt: new Date().toISOString(),
+                };
+            },
+            init: async () => {
+                frameworkLogger.log("processor-manager", "initializing AGENTS.md validation processor", "info");
+                try {
+                    const { AgentsMdValidationProcessor } = await import("./implementations/agents-md-validation-processor.js");
+                    const p = new AgentsMdValidationProcessor(process.cwd());
+                    const result = await p.execute({ tool: "validate", operation: "initialization" });
+                    if (!result.success && result.blocked) {
+                        frameworkLogger.log("processor-manager", "agents-md-validation", "info", {
+                            message: "AGENTS.md validation failed - commit operations may be blocked",
+                        });
+                    }
+                }
+                catch (error) {
+                    frameworkLogger.log("processor-manager", "agents-md-validation-init-error", "error", {
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            },
+        });
+        f.set("typescriptCompilation", {
+            execute: async (ctx) => {
+                const { runTypeScriptCompilation } = await import("./implementations/typescript-compilation-processor.js");
+                const cwd = ctx.directory || process.cwd();
+                return runTypeScriptCompilation(cwd);
+            },
+            init: async () => {
+                frameworkLogger.log("processor-manager", "initializing typescript compilation processor", "info");
+            },
+        });
+        f.set("spawnGovernance", {
+            execute: async (ctx) => {
+                const { runSpawnGovernance } = await import("./implementations/spawn-governance-processor.js");
+                return runSpawnGovernance(ctx);
+            },
+            init: async () => {
+                try {
+                    const { SpawnGovernanceProcessor } = await import("./implementations/spawn-governance-processor.js");
+                    frameworkLogger.log("processor-manager", "spawn-governance-processor-initialized", "success", {
+                        maxConcurrent: SpawnGovernanceProcessor.DEFAULT_MAX_CONCURRENT,
+                    });
+                }
+                catch (error) {
+                    frameworkLogger.log("processor-manager", "spawn-governance-init-failed", "error", {
+                        error: String(error),
+                    });
+                }
+            },
+        });
+        f.set("performanceBudget", {
+            execute: async (ctx) => {
+                const { runPerformanceBudgetCheck } = await import("./implementations/performance-budget-processor.js");
+                return runPerformanceBudgetCheck(ctx);
+            },
+            init: async () => {
+                try {
+                    const { PerformanceBudgetProcessor, DEFAULT_PERFORMANCE_BUDGET } = await import("./implementations/performance-budget-processor.js");
+                    frameworkLogger.log("processor-manager", "performance-budget-processor-initialized", "success", {
+                        config: DEFAULT_PERFORMANCE_BUDGET,
+                    });
+                }
+                catch (error) {
+                    frameworkLogger.log("processor-manager", "performance-budget-init-failed", "error", {
+                        error: String(error),
+                    });
+                }
+            },
+        });
+        f.set("asyncPattern", {
+            execute: async (ctx) => {
+                const { runAsyncPatternCheck } = await import("./implementations/async-pattern-processor.js");
+                return runAsyncPatternCheck(ctx);
+            },
+            init: async () => {
+                try {
+                    frameworkLogger.log("processor-manager", "async-pattern-processor-initialized", "success");
+                }
+                catch (error) {
+                    frameworkLogger.log("processor-manager", "async-pattern-init-failed", "error", {
+                        error: String(error),
+                    });
+                }
+            },
+        });
+        f.set("consoleLogGuard", {
+            execute: async (ctx) => {
+                const { runConsoleLogGuard } = await import("./implementations/console-log-guard-processor.js");
+                return runConsoleLogGuard(ctx);
+            },
+            init: async () => {
+                try {
+                    frameworkLogger.log("processor-manager", "console-log-guard-processor-initialized", "success");
+                }
+                catch (error) {
+                    frameworkLogger.log("processor-manager", "console-log-guard-init-failed", "error", {
+                        error: String(error),
+                    });
+                }
+            },
+        });
+        f.set("nudge", {
+            execute: async (ctx) => {
+                const { executeNudgeProcessor } = await import("./implementations/nudge-processor.js");
+                const result = await executeNudgeProcessor(ctx);
+                return result.data;
+            },
+            init: async () => {
+                frameworkLogger.log("processor-manager", "initializing nudge processor", "info");
+            },
+        });
+        f.set("consoleLogGuardPost", {
+            execute: async (ctx) => {
+                const { runConsoleLogGuard } = await import("./implementations/console-log-guard-processor.js");
+                return runConsoleLogGuard(ctx);
+            },
+        });
+        f.set("postProcessorChain", {
+            execute: async (ctx) => {
+                const { runPostProcessorChainValidation } = await import("./implementations/postprocessor-chain-validator.js");
+                return runPostProcessorChainValidation(ctx);
+            },
+            init: async () => {
+                frameworkLogger.log("processor-manager", "postprocessor-chain-initialized", "success");
+            },
+        });
+        f.set("commitBatcher", {
+            execute: async (ctx) => {
+                const { executeCommitBatcherProcessor } = await import("./implementations/commit-batcher-processor.js");
+                const result = await executeCommitBatcherProcessor(ctx);
+                return result.data;
+            },
+            init: async () => {
+                frameworkLogger.log("processor-manager", "initializing commit batcher processor", "info");
+            },
+        });
+        f.set("publishPreflight", {
+            execute: async (ctx) => {
+                const { PublishPreflightProcessor } = await import("./implementations/publish-preflight-processor.js");
+                const p = new PublishPreflightProcessor();
+                return p.execute(ctx);
+            },
+            init: async () => {
+                frameworkLogger.log("processor-manager", "publish-preflight-initialized", "success");
+            },
+        });
+        f.set("storytellingTrigger", {
+            execute: async (ctx) => {
+                const { StorytellingTriggerProcessor } = await import("./implementations/storytelling-trigger-processor.js");
+                const p = new StorytellingTriggerProcessor();
+                return p.execute(ctx);
+            },
+        });
+        f.set("inferenceImprovement", {
+            execute: async (ctx) => {
+                const { InferenceImprovementProcessor } = await import("./implementations/inference-improvement-processor.js");
+                const p = new InferenceImprovementProcessor();
+                return p.execute(ctx);
+            },
+        });
+        f.set("sessionSummary", {
+            execute: async (ctx) => {
+                const { SessionSummaryProcessor } = await import("./implementations/session-summary-processor.js");
+                const p = new SessionSummaryProcessor();
+                return p.execute(ctx);
+            },
+        });
+    }
+    registerFactory(name, factory) {
+        this.factories.set(name, factory);
+    }
+    registerProcessorWithHook(registration) {
+        const config = {
+            name: registration.name,
+            type: registration.type,
+            priority: registration.hook.priority,
+            enabled: registration.hook.enabled,
+        };
+        this.registerProcessor(config);
+        this.processors.set(registration.name, { ...config, hook: registration.hook });
+    }
+    registerProcessor(config) {
+        if (!config.name || config.name.trim().length === 0) {
+            throw new Error("Processor name cannot be empty");
+        }
+        if (config.name.includes(" ")) {
+            throw new Error("Processor name must be a valid identifier (no spaces)");
+        }
+        if (config.type !== "pre" && config.type !== "post") {
+            throw new Error('Processor type must be either "pre" or "post"');
+        }
+        if (config.priority < 0) {
+            throw new Error("Processor priority must be non-negative");
+        }
+        if (this.processors.has(config.name)) {
+            throw new Error(`Processor ${config.name} is already registered`);
+        }
+        this.processors.set(config.name, config);
+        this.metrics.set(config.name, {
+            totalExecutions: 0,
+            successfulExecutions: 0,
+            failedExecutions: 0,
+            averageDuration: 0,
+            lastExecutionTime: 0,
+            healthStatus: "healthy",
+        });
+        frameworkLogger.log("processor-manager", "processor registered", "success", {
+            name: config.name,
+            type: config.type,
+        });
+    }
+    unregisterProcessor(name) {
+        if (!this.processors.has(name)) {
+            throw new Error(`Processor ${name} is not registered`);
+        }
+        this.processors.delete(name);
+        this.metrics.delete(name);
+        this.activeProcessors.delete(name);
+        frameworkLogger.log("processor-manager", "processor unregistered", "success", { name });
+    }
+    getProcessors() {
+        return this.processors;
+    }
+    async initializeProcessors() {
+        const jobId = `init-processors-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+        frameworkLogger.log("processor-manager", "initializeProcessors called", "info", {
+            jobId,
+            totalProcessors: this.processors.size,
+            enabledProcessors: Array.from(this.processors.values()).filter((p) => p.enabled).length,
+        });
+        frameworkLogger.log("processor-manager", "initializing processors", "info", { jobId });
+        const initPromises = Array.from(this.processors.values())
+            .filter((p) => p.enabled)
+            .map(async (config) => {
+            try {
+                await this.initializeProcessor(config.name);
+                frameworkLogger.log("processor-manager", "processor initialized successfully", "success", {
+                    jobId,
+                    processor: config.name,
+                });
+                return { name: config.name, success: true };
+            }
+            catch (error) {
+                frameworkLogger.log("processor-manager", "processor initialization failed", "error", {
+                    jobId,
+                    processor: config.name,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                frameworkLogger.log("processor-manager", "processor-initialization-failed", "error", {
+                    processor: config.name,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return {
+                    name: config.name,
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        });
+        const results = await Promise.all(initPromises);
+        const failures = results.filter((r) => !r.success);
+        if (failures.length > 0) {
+            frameworkLogger.log("processor-manager", "batch-initialization-failed", "error", {
+                count: failures.length,
+                failures: failures.map((f) => f.error).join(", "),
+            });
+            return false;
+        }
+        return true;
+    }
+    async initializeProcessor(name) {
+        const config = this.processors.get(name);
+        if (!config) {
+            throw new Error(`Processor ${name} not found`);
+        }
+        const factory = this.factories.get(name);
+        if (factory?.init) {
+            await factory.init();
+        }
+        this.activeProcessors.add(name);
+    }
+    async executePreProcessors(input) {
+        const jobId = `execute-pre-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+        const { tool, args, context } = input;
+        frameworkLogger.log("processor-manager", "executePreProcessors called", "debug", {
+            jobId,
+            tool,
+            processorCount: Array.from(this.processors.values()).filter((p) => p.type === "pre" && p.enabled).length,
+        });
+        const preProcessors = Array.from(this.processors.values())
+            .filter((p) => p.type === "pre" && p.enabled)
+            .sort((a, b) => a.priority - b.priority);
+        if (args && typeof args === "object") {
+            const promptText = args.prompt ||
+                args.message ||
+                args.content ||
+                args.input;
+            if (promptText && typeof promptText === "string" && promptText.length > 10) {
+                try {
+                    const { promptSecurityValidator } = await import("../security/prompt-security-validator.js");
+                    const validation = promptSecurityValidator.validatePrompt(promptText);
+                    if (!validation.isSafe) {
+                        frameworkLogger.log("processor-manager", "prompt-security-blocked", "warning", {
+                            tool,
+                            riskLevel: validation.riskLevel,
+                            violations: validation.violations,
+                        });
+                        return {
+                            success: false,
+                            results: [
+                                {
+                                    success: false,
+                                    processorName: "prompt-security-validator",
+                                    error: `Prompt security violation: ${validation.violations.join(", ")}`,
+                                    duration: 0,
+                                },
+                            ],
+                        };
+                    }
+                }
+                catch {
+                    /* non-blocking */
+                }
+            }
+        }
+        const results = [];
+        for (const config of preProcessors) {
+            if (config.stagger?.minIntervalMs) {
+                const lastExec = this.lastExecutionTime.get(config.name) ?? 0;
+                const elapsed = Date.now() - lastExec;
+                const remaining = config.stagger.minIntervalMs - elapsed;
+                if (remaining > 0) {
+                    frameworkLogger.log("processor-manager", "stagger-wait", "debug", {
+                        processor: config.name,
+                        waitMs: remaining,
+                        minIntervalMs: config.stagger.minIntervalMs,
+                    });
+                    await new Promise((r) => setTimeout(r, remaining));
+                }
+            }
+            const result = await this.executeProcessor(config.name, context);
+            results.push(result);
+            this.lastExecutionTime.set(config.name, Date.now());
+            if (!result.success) {
+                frameworkLogger.log("processor-manager", "pre-processor failed", "info", {
+                    jobId,
+                    processor: config.name,
+                    tool,
+                    error: result.error,
+                });
+            }
+            else {
+                frameworkLogger.log("processor-manager", "pre-processor succeeded", "success", {
+                    jobId,
+                    processor: config.name,
+                    tool,
+                    duration: result.duration,
+                });
+            }
+        }
+        const overallSuccess = results.every((r) => r.success);
+        frameworkLogger.log("processor-manager", "executePreProcessors completed", "debug", {
+            jobId,
+            tool,
+            totalResults: results.length,
+            successCount: results.filter((r) => r.success).length,
+            overallSuccess,
+        });
+        return { success: overallSuccess, results };
+    }
+    async executePostProcessors(operation, data, preResults) {
+        const jobId = `execute-post-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+        frameworkLogger.log("processor-manager", "executePostProcessors called", "debug", {
+            jobId,
+            operation,
+            preResultCount: preResults.length,
+            processorCount: Array.from(this.processors.values()).filter((p) => p.type === "post" && p.enabled).length,
+        });
+        const postProcessors = Array.from(this.processors.values())
+            .filter((p) => p.type === "post" && p.enabled)
+            .sort((a, b) => a.priority - b.priority);
+        const results = [];
+        for (const config of postProcessors) {
+            if (config.stagger?.minIntervalMs) {
+                const lastExec = this.lastExecutionTime.get(config.name) ?? 0;
+                const elapsed = Date.now() - lastExec;
+                const remaining = config.stagger.minIntervalMs - elapsed;
+                if (remaining > 0) {
+                    frameworkLogger.log("processor-manager", "stagger-wait", "debug", {
+                        processor: config.name,
+                        waitMs: remaining,
+                        minIntervalMs: config.stagger.minIntervalMs,
+                    });
+                    await new Promise((r) => setTimeout(r, remaining));
+                }
+            }
+            const result = await this.executeProcessor(config.name, {
+                operation,
+                data,
+                preResults,
+            });
+            results.push(result);
+            if (!result.success) {
+                frameworkLogger.log("processor-manager", "post-processor failed", "error", {
+                    jobId,
+                    processor: config.name,
+                    operation,
+                    error: result.error,
+                });
+            }
+            else {
+                frameworkLogger.log("processor-manager", "post-processor succeeded", "success", {
+                    jobId,
+                    processor: config.name,
+                    operation,
+                    duration: result.duration,
+                });
+            }
+        }
+        frameworkLogger.log("processor-manager", "executePostProcessors completed", "debug", {
+            jobId,
+            operation,
+            totalResults: results.length,
+            successCount: results.filter((r) => r.success).length,
+        });
+        return results;
+    }
+    async executeProcessor(name, context) {
+        const config = this.processors.get(name);
+        if (!config) {
+            throw new Error(`Processor ${name} not found`);
+        }
+        const safeContext = context ?? {};
+        if (safeContext && typeof safeContext === "object" && !Array.isArray(safeContext)) {
+            const validationResult = this.validateProcessorContext(name, context);
+            if (!validationResult.valid) {
+                await frameworkLogger.log("processor-manager", "context-validation-failed", "info", {
+                    processor: name,
+                    errors: validationResult.errors,
+                });
+            }
+        }
+        const startTime = Date.now();
+        const metrics = this.metrics.get(name);
+        try {
+            const factory = this.factories.get(name);
+            if (!factory) {
+                throw new Error(`Unknown processor: ${name}`);
+            }
+            const result = await factory.execute(safeContext);
+            const duration = Date.now() - startTime;
+            this.updateMetrics(name, true, duration);
+            return { success: true, data: result, duration, processorName: name };
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            this.updateMetrics(name, false, duration);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                duration,
+                processorName: name,
+            };
+        }
+    }
+    updateMetrics(name, success, duration) {
+        const metrics = this.metrics.get(name);
+        metrics.totalExecutions++;
+        metrics.lastExecutionTime = Date.now();
+        if (success) {
+            metrics.successfulExecutions++;
+        }
+        else {
+            metrics.failedExecutions++;
+        }
+        const totalDuration = metrics.averageDuration * (metrics.totalExecutions - 1) + duration;
+        metrics.averageDuration = totalDuration / metrics.totalExecutions;
+        const successRate = metrics.successfulExecutions / metrics.totalExecutions;
+        metrics.healthStatus =
+            successRate > 0.95 ? "healthy" : successRate > 0.8 ? "degraded" : "failed";
+    }
+    getProcessorHealth() {
+        return Array.from(this.activeProcessors).map((name) => {
+            const metrics = this.metrics.get(name);
+            const totalExecutions = metrics.totalExecutions || 1;
+            return {
+                name,
+                status: metrics.healthStatus,
+                lastExecution: metrics.lastExecutionTime,
+                successRate: metrics.successfulExecutions / totalExecutions,
+                averageDuration: metrics.averageDuration,
+                errorCount: metrics.failedExecutions,
+            };
+        });
+    }
+    validateProcessorContext(processorName, context) {
+        const errors = [];
+        if (!context || typeof context !== "object") {
+            return { valid: true, errors: [] };
+        }
+        if (Array.isArray(context)) {
+            return { valid: true, errors: [] };
+        }
+        const contextData = context.data;
+        if (contextData && typeof contextData !== "object") {
+            return { valid: true, errors: [] };
+        }
+        const requiredFields = {
+            preValidate: ["operation"],
+            codexCompliance: ["operation"],
+            testAutoCreation: ["tool", "operation"],
+            versionCompliance: ["operation"],
+            errorBoundary: ["operation"],
+            testExecution: ["tool"],
+            regressionTesting: ["operation"],
+            stateValidation: ["operation"],
+            agentsMdValidation: ["tool", "operation"],
+        };
+        const required = requiredFields[processorName] || [];
+        for (const field of required) {
+            if (!(field in context) && !(field in (context.data || {}))) {
+                errors.push(`Missing required field: ${field}`);
+            }
+        }
+        if (errors.length > 0) {
+            frameworkLogger.log("processor-manager", "context-validation-warnings", "info", {
+                processor: processorName,
+                errors,
+                contextKeys: Object.keys(context),
+            });
+        }
+        return { valid: errors.length === 0, errors };
+    }
+    resolveProcessorConflicts(conflicts) {
+        if (conflicts.length === 0) {
+            throw new Error("No conflicts to resolve");
+        }
+        const successful = conflicts.find((c) => c.success);
+        if (successful) {
+            return successful;
+        }
+        return conflicts[0];
+    }
+    async cleanupProcessors() {
+        frameworkLogger.log("processor-manager", "cleaning up processors", "info");
+        for (const name of this.activeProcessors) {
+            try {
+                await this.cleanupProcessor(name);
+            }
+            catch (error) {
+                frameworkLogger.log("processor-manager", "processor-cleanup-failed", "error", {
+                    processor: name,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        this.activeProcessors.clear();
+        this.processors.clear();
+        this.metrics.clear();
+    }
+    async cleanupProcessor(name) {
+        // Processor-specific cleanup is handled by the processor classes themselves
+        void name;
+    }
+}