0xray 3.0.12 → 3.1.0

package/dist/processors/processor-manager.js

@@ -103,361 +103,329 @@ export class ProcessorManager {
         return new Ctor(...resolved);
     }
     registerBuiltInFactories() {
-        const factoryConfigs = [
-            {
-                name: "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");
-                },
-            },
-            {
-                name: "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");
-                },
-            },
-            {
-                name: "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;
-                },
-            },
-            {
-                name: "versionCompliance",
-                execute: async (ctx) => {
+        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();
-                    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}`,
-                            });
-                        }
+                    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,
+                        });
                     }
-                    catch (error) {
-                        frameworkLogger.log("processor-manager", "version-compliance-init-error", "error", {
-                            error: error instanceof Error ? error.message : String(error),
+                    else {
+                        frameworkLogger.log("processor-manager", "version-compliance", "info", {
+                            message: `Version compliance verified: NPM ${result.npmVersion}, UVM ${result.uvmVersion}`,
                         });
                     }
-                },
-            },
-            {
-                name: "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");
-                },
-            },
-            {
-                name: "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");
-                },
-            },
-            {
-                name: "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");
-                },
-            },
-            {
-                name: "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");
-                },
-            },
-            {
-                name: "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;
-                },
-            },
-            {
-                name: "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");
-                },
-            },
-            {
-                name: "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;
-                },
-            },
-            {
-                name: "agentsMdValidation",
-                execute: async (ctx) => {
+                }
+                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: 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),
-                        });
-                    }
-                },
-            },
-            {
-                name: "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");
-                },
-            },
-            {
-                name: "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),
-                        });
-                    }
-                },
-            },
-            {
-                name: "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,
+                    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", "performance-budget-init-failed", "error", {
-                            error: String(error),
-                        });
-                    }
-                },
-            },
-            {
-                name: "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),
-                        });
-                    }
-                },
-            },
-            {
-                name: "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),
-                        });
-                    }
-                },
-            },
-            {
-                name: "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");
-                },
-            },
-            {
-                name: "consoleLogGuardPost",
-                execute: async (ctx) => {
-                    const { runConsoleLogGuard } = await import("./implementations/console-log-guard-processor.js");
-                    return runConsoleLogGuard(ctx);
-                },
-            },
-            {
-                name: "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");
-                },
-            },
-            {
-                name: "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");
-                },
-            },
-            {
-                name: "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");
-                },
-            },
-            {
-                name: "storytellingTrigger",
-                execute: async (ctx) => {
-                    const { StorytellingTriggerProcessor } = await import("./implementations/storytelling-trigger-processor.js");
-                    const p = new StorytellingTriggerProcessor();
-                    return p.execute(ctx);
-                },
-            },
-            {
-                name: "inferenceImprovement",
-                execute: async (ctx) => {
-                    const { InferenceImprovementProcessor } = await import("./implementations/inference-improvement-processor.js");
-                    const p = new InferenceImprovementProcessor();
-                    return p.execute(ctx);
-                },
-            },
-            {
-                name: "sessionSummary",
-                execute: async (ctx) => {
-                    const { SessionSummaryProcessor } = await import("./implementations/session-summary-processor.js");
-                    const p = new SessionSummaryProcessor();
-                    return p.execute(ctx);
-                },
-            },
-        ];
-        for (const config of factoryConfigs) {
-            this.registerFactory(config.name, {
-                execute: config.execute,
-                ...(config.init ? { init: config.init } : {}),
-            });
-        }
+                }
+                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);
@@ -590,7 +558,7 @@ export class ProcessorManager {
                 args.input;
             if (promptText && typeof promptText === "string" && promptText.length > 10) {
                 try {
-                    const { promptSecurityValidator } = await import("../mcps/shared/prompt-security-validator.js");
+                    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", {
@@ -856,4 +824,3 @@ export class ProcessorManager {
         void name;
     }
 }
-//# sourceMappingURL=processor-manager.js.map