0xray 2.1.2 → 2.1.4

package/dist/postprocessor/PostProcessor.js

@@ -7,25 +7,25 @@
  * @version 1.0.0
  * @since 2026-01-13
  */
-import * as path from "path";
 import { frameworkLogger } from "../core/framework-logger.js";
-import { resolveConfigPath } from "../core/config-paths.js";
 import { GitHookTrigger } from "./triggers/GitHookTrigger.js";
 import { WebhookTrigger } from "./triggers/WebhookTrigger.js";
 import { APITrigger } from "./triggers/APITrigger.js";
 import { PostProcessorMonitoringEngine } from "./monitoring/MonitoringEngine.js";
 import { FailureAnalysisEngine } from "./analysis/FailureAnalysisEngine.js";
+import { CodeChangeAnalyzer } from "./analysis/CodeChangeAnalyzer.js";
 import { AutoFixEngine } from "./autofix/AutoFixEngine.js";
 import { activity } from "../core/activity-logger.js";
 import { FixValidator } from "./autofix/FixValidator.js";
-import { mcpClientManager } from "../mcps/mcp-client.js";
 import { RedeployCoordinator } from "./redeploy/RedeployCoordinator.js";
 import { EscalationEngine } from "./escalation/EscalationEngine.js";
 import { SuccessHandler } from "./success/SuccessHandler.js";
 import { defaultConfig } from "./config.js";
-import { frameworkReportingSystem } from "../reporting/framework-reporting-system.js";
 import { ReportContentValidator } from "../validation/report-content-validator.js";
+import { PostProcessorReporter } from "./reporting/PostProcessorReporter.js";
 import { RegressionAnalysisService } from "./services/RegressionAnalysisService.js";
+import { ProcessorConfigLoader } from "./config/ProcessorConfigLoader.js";
+import { ArchitecturalComplianceChecker } from "./compliance/ArchitecturalComplianceChecker.js";
 export class PostProcessor {
     stateManager;
     sessionMonitor;
@@ -35,11 +35,15 @@ export class PostProcessor {
     autoFixEngine;
     fixValidator;
     reportValidator;
+    reporter;
     regressionAnalysisService;
+    configLoader;
+    codeAnalyzer;
     redeployCoordinator;
     escalationEngine;
     successHandler;
     triggers;
+    complianceChecker;
     constructor(stateManager, sessionMonitor = null, config = {}) {
         this.stateManager = stateManager;
         this.sessionMonitor = sessionMonitor;
@@ -51,7 +55,10 @@ export class PostProcessor {
         this.autoFixEngine = new AutoFixEngine(this.config.autoFix.confidenceThreshold);
         this.fixValidator = new FixValidator();
         this.reportValidator = new ReportContentValidator();
+        this.reporter = new PostProcessorReporter(this.config, this.reportValidator);
         this.regressionAnalysisService = new RegressionAnalysisService();
+        this.configLoader = new ProcessorConfigLoader();
+        this.codeAnalyzer = new CodeChangeAnalyzer();
         // Initialize redeploy coordinator
         this.redeployCoordinator = new RedeployCoordinator(this.config.redeploy);
         // Initialize escalation and success handlers
@@ -63,169 +70,14 @@ export class PostProcessor {
             webhook: new WebhookTrigger(this),
             api: new APITrigger(this, {}), // Pass empty config object
         };
-    }
-    /**
-     * Generate automated framework report if conditions are met
-     */
-    async generateFrameworkReport(complexityScore, context, sessionId) {
-        if (!this.config.reporting.enabled || !this.config.reporting.autoGenerate) {
-            return null;
-        }
-        // Only generate report if complexity score meets threshold
-        if (complexityScore < this.config.reporting.reportThreshold) {
-            await frameworkLogger.log("postprocessor", "report-skipped-low-complexity", "info", {
-                complexityScore,
-                threshold: this.config.reporting.reportThreshold,
-            });
-            return null;
-        }
-        try {
-            await frameworkLogger.log("-post-processor", "-generating-automated-framework-report-", "info", { message: "📊 Generating automated framework report..." });
-            const reportConfig = {
-                type: "full-analysis",
-                sessionId,
-                outputFormat: "markdown",
-                outputPath: path.join(this.config.reporting.reportDir, `framework-report-${context.commitSha}-${new Date().toISOString().split("T")[0]}.md`),
-                detailedMetrics: true,
-                timeRange: { lastHours: 24 },
-            };
-            await frameworkReportingSystem.generateReport(reportConfig);
-            await frameworkLogger.log("-post-processor", "-framework-report-generated-reportconfig-outputpat", "success", {
-                message: `✅ Framework report generated: ${reportConfig.outputPath}`,
-            });
-            // Clean up old reports
-            await this.cleanupOldReports();
-            return reportConfig.outputPath;
-        }
-        catch (error) {
-            await frameworkLogger.log("postprocessor", "framework-report-generation-failed", "warning", { error: String(error) });
-            return null;
-        }
-    }
-    /**
-     * Validate generated reports for hidden issues
-     */
-    async validateGeneratedReport(reportPath, reportType) {
-        try {
-            if (this.reportValidator) {
-                const validation = await this.reportValidator.validateReportContent(reportPath, reportType);
-                if (!validation.valid) {
-                    await frameworkLogger.log("postprocessor", "report-validation-failed", "warning", { reportPath, issues: validation.issues });
-                    if (validation.details.criticalErrors.length > 0) {
-                        await frameworkLogger.log("postprocessor", "critical-errors-in-report", "error", { reportPath, criticalErrors: validation.details.criticalErrors });
-                    }
-                }
-                else {
-                    await frameworkLogger.log("postprocessor", "report-validation-passed", "success", { reportPath });
-                }
-            }
-        }
-        catch (error) {
-            await frameworkLogger.log("postprocessor", "report-validation-failed", "warning", { error: String(error) });
-        }
-    }
-    /**
-     * Clean up old reports based on retention policy
-     */
-    async cleanupOldReports() {
-        try {
-            const fs = await import("fs");
-            const path = await import("path");
-            const reportDir = this.config.reporting.reportDir;
-            if (!fs.existsSync(reportDir))
-                return;
-            const files = fs.readdirSync(reportDir);
-            const cutoffTime = Date.now() - this.config.reporting.retentionDays * 24 * 60 * 60 * 1000;
-            for (const file of files) {
-                const filePath = path.join(reportDir, file);
-                const stats = fs.statSync(filePath);
-                if (stats.mtime.getTime() < cutoffTime) {
-                    fs.unlinkSync(filePath);
-                    await frameworkLogger.log("postprocessor", "cleaned-up-old-report", "info", { file });
-                }
-            }
-        }
-        catch (error) {
-            await frameworkLogger.log("postprocessor", "report-cleanup-failed", "warning", { error: String(error) });
-        }
-    }
-    /**
-     * Analyze code changes to provide meaningful context to processors
-     * FIX: Issue #1 - Pass actual code analysis to processors
-     */
-    async analyzeCodeChanges(context) {
-        const fs = await import("fs");
-        const path = await import("path");
-        const newCode = new Map();
-        const existingCode = new Map();
-        const tests = [];
-        const dependencies = [];
-        try {
-            // Read new/changed files
-            for (const file of context.files || []) {
-                try {
-                    const fullPath = path.join(process.cwd(), file);
-                    if (fs.existsSync(fullPath)) {
-                        // Read new code
-                        const content = fs.readFileSync(fullPath, "utf-8");
-                        newCode.set(file, content);
-                        // Check for test files
-                        if (file.includes(".test.") || file.includes(".spec.")) {
-                            tests.push(file);
-                        }
-                        // Check for package.json or dependency files
-                        if (file.includes("package.json") || file.includes("requirements.txt") || file.includes("Cargo.toml")) {
-                            dependencies.push(file);
-                        }
-                    }
-                }
-                catch (error) {
-                    // Skip files that can't be read
-                    await frameworkLogger.log("-post-processor", "-code-analysis-file-error", "info", { message: `Could not analyze ${file}: ${error}` });
-                }
-            }
-            await frameworkLogger.log("-post-processor", "-code-analysis-complete", "info", {
-                message: `Analyzed ${newCode.size} files, ${tests.length} tests, ${dependencies.length} dependencies`,
-            });
-        }
-        catch (error) {
-            await frameworkLogger.log("-post-processor", "-code-analysis-failed", "error", { message: `Code analysis failed: ${error}` });
-        }
-        return {
-            operation: "commit",
-            files: context.files || [],
-            newCode,
-            existingCode,
-            tests,
-            dependencies,
-        };
-    }
-    /**
-     * Load processor configuration from features.json
-     * FIX: Issue #2 - Make processor registration configurable
-     */
-    async loadProcessorConfig() {
-        const fs = await import("fs");
-        const path = await import("path");
-        try {
-            const configPath = resolveConfigPath("features.json") ?? path.join(process.cwd(), ".opencode", "xray", "features.json");
-            if (fs.existsSync(configPath)) {
-                const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
-                return config.processors || {};
-            }
-        }
-        catch (error) {
-            frameworkLogger.log("postprocessor", "processor-config-load-failed", "info", {
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-        return {};
+        // Initialize architectural compliance checker
+        this.complianceChecker = new ArchitecturalComplianceChecker();
     }
     /**
      * Initialize the post-processor system
      */
     async initialize() {
-        await frameworkLogger.log("-post-processor", "-initializing-stringray-post-processor-", "info", { message: "🚀 Initializing 0xRay Post-Processor..." });
+        await frameworkLogger.log("postprocessor", "initialize", "info", { message: "🚀 Initializing 0xRay Post-Processor..." });
         // Initialize monitoring
         if (this.config.monitoring.enabled) {
             await this.monitoringEngine.initialize();
@@ -255,301 +107,7 @@ export class PostProcessor {
                 message: "Memory monitor not available",
             });
         }
-        await frameworkLogger.log("-post-processor", "-post-processor-initialization-complete-", "info", { message: "🎯 Post-Processor initialization complete" });
-    }
-    /**
-     * Validate architectural compliance against codex rules
-     */
-    async validateArchitecturalCompliance(context) {
-        try {
-            await frameworkLogger.log("-post-processor", "-validating-architectural-compliance-", "info", { message: "🏗️ Validating architectural compliance..." });
-            // Rule 46: System Integrity Cross-Check
-            const integrityCheck = await this.checkSystemIntegrity(context);
-            if (!integrityCheck.passed) {
-                await frameworkLogger.log("-post-processor", "-system-integrity-violation-integritycheck-message", "error", {
-                    message: `❌ System integrity violation: ${integrityCheck.message}`,
-                });
-                // Call researcher agent to analyze system components
-                const fixed = await this.callAgentForArchitecturalFix("checkSystemIntegrity", "researcher", "project-analysis", context, integrityCheck.message);
-                if (!fixed) {
-                    return false; // Could not auto-fix
-                }
-            }
-            // Rule 47: Integration Testing Mandate
-            const integrationCheck = await this.checkIntegrationTesting(context);
-            if (!integrationCheck.passed) {
-                await frameworkLogger.log("-post-processor", "-integration-testing-violation-integrationcheck-me", "error", {
-                    message: `❌ Integration testing violation: ${integrationCheck.message}`,
-                });
-                // Call testing-lead agent for testing strategy
-                const fixed = await this.callAgentForArchitecturalFix("checkIntegrationTesting", "testing-lead", "testing-strategy", context, integrationCheck.message);
-                if (!fixed) {
-                    return false; // Could not auto-fix
-                }
-            }
-            // Rule 48: Path Resolution Abstraction
-            const pathCheck = await this.checkPathResolution(context);
-            if (!pathCheck.passed) {
-                await frameworkLogger.log("-post-processor", "-path-resolution-violation-pathcheck-message-", "error", { message: `❌ Path resolution violation: ${pathCheck.message}` });
-                // Call researcher + refactorer for path analysis and fixes
-                const fixed = await this.callAgentForArchitecturalFix("checkPathResolution", "researcher", "project-analysis", context, pathCheck.message);
-                if (!fixed) {
-                    return false; // Could not auto-fix
-                }
-            }
-            // Rule 49: Feature Completeness Validation
-            const completenessCheck = await this.checkFeatureCompleteness(context);
-            if (!completenessCheck.passed) {
-                await frameworkLogger.log("-post-processor", "-feature-completeness-violation-completenesscheck-", "error", {
-                    message: `❌ Feature completeness violation: ${completenessCheck.message}`,
-                });
-                // Call architect agent for system design analysis
-                const fixed = await this.callAgentForArchitecturalFix("checkFeatureCompleteness", "architect", "architecture-patterns", context, completenessCheck.message);
-                if (!fixed) {
-                    return false; // Could not auto-fix
-                }
-            }
-            // Rule 50: Path Analysis Guidelines Enforcement
-            const pathGuidelinesCheck = await this.checkPathAnalysisGuidelines(context);
-            if (!pathGuidelinesCheck.passed) {
-                await frameworkLogger.log("-post-processor", "-path-analysis-guidelines-violation-pathguidelines", "error", {
-                    message: `❌ Path analysis guidelines violation: ${pathGuidelinesCheck.message}`,
-                });
-                // Call refactorer agent for code refactoring
-                const fixed = await this.callAgentForArchitecturalFix("checkPathAnalysisGuidelines", "refactorer", "refactoring-strategies", context, pathGuidelinesCheck.message);
-                if (!fixed) {
-                    return false; // Could not auto-fix
-                }
-            }
-            await frameworkLogger.log("-post-processor", "-all-architectural-compliance-checks-passed-", "success", { message: "✅ All architectural compliance checks passed" });
-            return true;
-        }
-        catch (error) {
-            await frameworkLogger.log("-post-processor", "-architectural-compliance-validation-failed-error-", "error", {
-                message: `❌ Architectural compliance validation failed: ${error instanceof Error ? error.message : String(error)}`,
-            });
-            return false;
-        }
-    }
-    async checkSystemIntegrity(context) {
-        // Check if all critical framework components are active
-        const stateManager = globalThis.strRayStateManager;
-        const postProcessor = globalThis.strRayPostProcessor;
-        if (!stateManager) {
-            try {
-                const { StrRayStateManager } = await import("../state/state-manager.js");
-                const tempStateManager = new StrRayStateManager();
-                globalThis.strRayStateManager = tempStateManager;
-                return {
-                    passed: true,
-                    message: "System integrity verified (graceful mode)",
-                };
-            }
-            catch (e) {
-                return {
-                    passed: true,
-                    message: "System integrity assumed OK (no full framework context)",
-                };
-            }
-        }
-        if (!postProcessor) {
-            return {
-                passed: true,
-                message: "System integrity verified (state manager active)",
-            };
-        }
-        return { passed: true, message: "System integrity verified" };
-    }
-    async checkIntegrationTesting(context) {
-        // For now, we assume integration testing has been run as part of the CI/CD process
-        // In a full implementation, this would check actual test results
-        return {
-            passed: true,
-            message: "Integration testing assumed to be completed in CI/CD pipeline",
-        };
-    }
-    async checkPathResolution(context) {
-        // Check for path resolution issues in committed files
-        // This would require reading the actual file contents from git
-        // For now, we verify that the framework's path resolution is working
-        const pathResolver = globalThis.strRayPathResolver;
-        if (!pathResolver) {
-            return {
-                passed: true,
-                message: "Path resolution check skipped (no full framework context)",
-            };
-        }
-        // Test path resolution with a sample path
-        try {
-            const resolvedPath = pathResolver.resolveAgentPath("test-agent");
-            if (resolvedPath.includes("../") || resolvedPath.includes("./dist")) {
-                return {
-                    passed: false,
-                    message: "Path resolution returning hardcoded paths",
-                };
-            }
-            return { passed: true, message: "Path resolution abstraction verified" };
-        }
-        catch (error) {
-            return {
-                passed: false,
-                message: `Path resolution failed: ${error instanceof Error ? error.message : String(error)}`,
-            };
-        }
-    }
-    async checkFeatureCompleteness(context) {
-        // This is a simplified check - in practice, we'd analyze the commit and PR data
-        // For now, we assume completeness based on the context having required fields
-        // Graceful degradation - assume OK if no full commit context
-        if (!context.commitSha || !context.repository) {
-            return {
-                passed: true,
-                message: "Feature completeness assumed OK (no full commit context)",
-            };
-        }
-        return { passed: true, message: "Feature completeness verified" };
-    }
-    /**
-     * Rule 50: Path Analysis Guidelines Enforcement
-     * Ensures AIs follow path resolution guidelines for all write/edit operations
-     * Covers all 3 types of path violations from PATH_RESOLUTION_ANALYSIS.md
-     */
-    async checkPathAnalysisGuidelines(context) {
-        // Check if the current operation involves code changes that might introduce path issues
-        if (!context.files || context.files.length === 0) {
-            return { passed: true, message: "No files to check for path guidelines" };
-        }
-        // Check for TypeScript/JavaScript files that might contain imports
-        const codeFiles = context.files.filter((file) => file.endsWith(".ts") ||
-            file.endsWith(".js") ||
-            file.endsWith(".tsx") ||
-            file.endsWith(".jsx"));
-        if (codeFiles.length === 0) {
-            return {
-                passed: true,
-                message: "No code files to validate for path guidelines",
-            };
-        }
-        // For write/edit operations, notify AIs about ALL THREE types of path violations
-        const guidelinesMessage = `
-🚨 CRITICAL: PATH ANALYSIS GUIDELINES ENFORCEMENT 🚨
-
-AI Operations Detected: ${context.trigger} trigger with ${codeFiles.length} code file(s)
-MANDATORY COMPLIANCE REQUIRED - VIOLATIONS WILL BLOCK COMMITS
-
-═══════════════════════════════════════════════════════════════
-🔴 TYPE 1: HARDCODED 'dist/' PATHS (17 files affected)
-═══════════════════════════════════════════════════════════════
-
-❌ NEVER use hardcoded 'dist/' paths in source code:
-\`\`\`typescript
-// WRONG - Breaks across environments (actual violations found)
-import { RuleEnforcer } from "../enforcement/rule-enforcer.js";
-// FIXED: Removed hardcoded dist/ path (was causing dist/dist corruption in builds)
-\`\`\`
-
-✅ CORRECT - Use import resolver for environment awareness:
-\`\`\`typescript
-// Environment-aware imports (Solution C)
-const { importResolver } = await import('./utils/import-resolver.js');
-const { RuleEnforcer } = await importResolver.importModule('enforcement/rule-enforcer');
-\`\`\`
-
-═══════════════════════════════════════════════════════════════
-🟡 TYPE 2: PROBLEMATIC '../' IMPORTS (107 files affected)
-═══════════════════════════════════════════════════════════════
-
-❌ Directory structure assumptions that break across environments:
-\`\`\`typescript
-// WRONG - Assumes specific deployment structure
-import { AgentConfig } from "../agents/code-reviewer.js"; // May break if directories move
-import { Utils } from "../../../shared/utils.js"; // Fragile deep navigation
-\`\`\`
-
-✅ CORRECT - Use stable relative imports within modules:
-\`\`\`typescript
-// Stable within src/ directory structure
-import { AgentConfig } from "../agents/code-reviewer.js"; // OK within same project
-import { Utils } from "../../shared/utils.js"; // Prefer shallower paths
-\`\`\`
-
-═══════════════════════════════════════════════════════════════
-🟠 TYPE 3: BRITTLE './' IMPORTS (151 files affected)
-═══════════════════════════════════════════════════════════════
-
-❌ Local file assumptions that break when files move:
-\`\`\`typescript
-// WRONG - Assumes file exists in specific location
-import { Config } from "./config.js"; // May not exist in built version
-import { Utils } from "./utils/helpers.js"; // Breaks if directory reorganized
-\`\`\`
-
-✅ CORRECT - Use proper module resolution:
-\`\`\`typescript
-// Prefer named imports from index files
-import { Config } from "./config/index.js";
-import { helpers } from "./utils/index.js";
-
-// Or use full relative paths when necessary
-import { Config } from "./config/config.js";
-\`\`\`
-
-═══════════════════════════════════════════════════════════════
-🛠️ RECOMMENDED SOLUTIONS FROM PATH_RESOLUTION_ANALYSIS.md
-═══════════════════════════════════════════════════════════════
-
-**Solution A: Environment Variables (Simple)**
-\`\`\`typescript
-const AGENTS_PATH = process.env.STRRAY_AGENTS_PATH || '../agents';
-import { AgentConfig } from \`\${AGENTS_PATH}/code-reviewer.js\`;
-\`\`\`
-
-**Solution B: Directory Structure Alignment (Architectural)**
-- Ensure build output matches source structure
-- Use aligned plugin/component directories
-- No code changes needed when structure is correct
-
-**Solution C: Import Resolver (Recommended)**
-\`\`\`typescript
-const { importResolver } = await import('./utils/import-resolver.js');
-const { Module } = await importResolver.importModule('path/to/module');
-\`\`\`
-
-═══════════════════════════════════════════════════════════════
-⚠️  ENFORCEMENT LEVELS
-═══════════════════════════════════════════════════════════════
-
-🔴 BLOCKING: Hardcoded dist/ paths in source files
-🟡 WARNING: Problematic deep ../ navigation (>3 levels)
-🟠 MONITOR: Brittle ./ imports (logged for review)
-
-AI MUST use appropriate solution based on context:
-- Development scripts → Solution A (Environment Variables)
-- Plugin components → Solution B (Directory Alignment)
-- Dynamic imports → Solution C (Import Resolver)
-
-═══════════════════════════════════════════════════════════════
-📖 REFERENCE: PATH_RESOLUTION_ANALYSIS.md
-═══════════════════════════════════════════════════════════════
-
-Complete guidelines available in project documentation.
-All path violations will be automatically detected and blocked.
-`;
-        // Log the comprehensive guidelines notification for AIs
-        await frameworkLogger.log("-post-processor", "guidelinesmessage", "info", {
-            message: guidelinesMessage,
-        });
-        // In a full implementation, we would:
-        // 1. Scan actual file contents for violations
-        // 2. Use git diff to check changed imports
-        // 3. Validate against all three violation types
-        // 4. Block commits with actual violations found
-        // For now, we provide comprehensive guidance and assume compliance
-        // Future enhancement: Implement actual file scanning and blocking
-        return {
-            passed: true,
-            message: "Comprehensive path analysis guidelines notification sent to AI operations",
-        };
+        await frameworkLogger.log("postprocessor", "initialize-complete", "info", { message: "🎯 Post-Processor initialization complete" });
     }
     /**
      * Execute the complete post-processor loop
@@ -558,13 +116,13 @@ All path violations will be automatically detected and blocked.
         const jobId = `post-processor-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
         const startTime = Date.now();
         const sessionId = `postprocessor-${context.commitSha}-${Date.now()}`;
-        await frameworkLogger.log("-post-processor", "-starting-post-processor-loop-for-commit-context-c", "info", {
+        await frameworkLogger.log("postprocessor", "loop-start", "info", {
             message: `🔄 Starting post-processor loop for commit: ${context.commitSha}`,
         });
         // Validate architectural compliance before processing
-        const compliancePassed = await this.validateArchitecturalCompliance(context);
+        const compliancePassed = await this.complianceChecker.validateArchitecturalCompliance(context);
         if (!compliancePassed) {
-            await frameworkLogger.log("-post-processor", "-architectural-compliance-validation-failed-blocki", "error", {
+            await frameworkLogger.log("postprocessor", "compliance-validation-failed", "error", {
                 message: "❌ Architectural compliance validation failed - blocking post-processing",
             });
             return {
@@ -577,12 +135,12 @@ All path violations will be automatically detected and blocked.
         }
         // Codex compliance validation: Use processor-manager for proper rule enforcement and agent delegation
         // IMPROVED: Analyze actual code changes and pass meaningful context to processors
-        const processorContext = await this.analyzeCodeChanges(context);
+        const processorContext = await this.codeAnalyzer.analyzeCodeChanges(context);
         try {
             const { importResolver } = await import("../utils/import-resolver.js");
             const { ProcessorManager } = await importResolver.importModule("processors/processor-manager");
             const processorManager = new ProcessorManager(this.stateManager);
-            const processorConfig = await this.loadProcessorConfig();
+            const processorConfig = await this.configLoader.loadProcessorConfig();
             const PRE_PROCESSOR_DEFAULTS = {
                 preValidate: { type: "pre", priority: 10 },
                 codexCompliance: { type: "pre", priority: 20 },
@@ -652,7 +210,7 @@ All path violations will be automatically detected and blocked.
                         }
                         catch (testError) {
                             // Non-blocking - log but continue
-                            await frameworkLogger.log("-post-processor", "-test-auto-creation-failed", "info", {
+                            await frameworkLogger.log("postprocessor", "test-auto-creation-failed", "info", {
                                 message: `Test auto-creation failed for ${filePath}: ${testError}`,
                             });
                         }
@@ -666,13 +224,13 @@ All path violations will be automatically detected and blocked.
                     violations: complianceResult.violations,
                     reason: "Codex compliance violations found - processor-manager attempted automated fixes",
                 });
-                await frameworkLogger.log("-post-processor", "-codex-compliance-violations-detected-processor-ma", "info", {
+                await frameworkLogger.log("postprocessor", "codex-compliance-violations-detected", "info", {
                     message: "⚠️ Codex compliance violations detected - processor-manager handled automated fixes",
                 });
             }
         }
         catch (error) {
-            await frameworkLogger.log("-post-processor", "-codex-compliance-check-failed-continuing-with-com", "error", {
+            await frameworkLogger.log("postprocessor", "codex-compliance-check-failed", "error", {
                 message: "⚠️ Codex compliance check failed - continuing with commit",
             });
         }
@@ -692,7 +250,7 @@ All path violations will be automatically detected and blocked.
                 endTime: Date.now(),
                 duration: Date.now() - startTime,
             });
-            await frameworkLogger.log("-post-processor", "-post-processor-loop-completed-result-success-succ", "success", {
+            await frameworkLogger.log("postprocessor", "loop-completed", "success", {
                 message: `✅ Post-processor loop completed: ${result.success ? "SUCCESS" : "FAILED"}`,
             });
             return result;
@@ -725,14 +283,14 @@ All path violations will be automatically detected and blocked.
         const monitoringResults = [];
         while (attempts < maxAttempts) {
             attempts++;
-            await frameworkLogger.log("-post-processor", "-monitoring-attempt-attempts-maxattempts-for-conte", "info", {
+            await frameworkLogger.log("postprocessor", "monitoring-attempt", "info", {
                 message: `🔍 Monitoring attempt ${attempts}/${maxAttempts} for ${context.commitSha}`,
             });
             // Monitor CI/CD status
             const monitoringResult = await this.monitoringEngine.monitorDeployment(context.commitSha);
             monitoringResults.push(monitoringResult);
             if (monitoringResult.overallStatus === "success") {
-                await frameworkLogger.log("-post-processor", "-ci-cd-pipeline-successful-post-processor-complete", "success", { message: "✅ CI/CD pipeline successful - post-processor complete" });
+                await frameworkLogger.log("postprocessor", "pipeline-success", "success", { message: "✅ CI/CD pipeline successful - post-processor complete" });
                 const result = {
                     success: true,
                     commitSha: context.commitSha,
@@ -791,7 +349,7 @@ All path violations will be automatically detected and blocked.
                     const { importResolver: resolver } = await import("../utils/import-resolver.js");
                     const { ProcessorManager: PM } = await resolver.importModule("processors/processor-manager");
                     const pm = new PM(this.stateManager);
-                    const postProcessorConfig = await this.loadProcessorConfig();
+                    const postProcessorConfig = await this.configLoader.loadProcessorConfig();
                     const POST_MAP = {
                         storytellingTrigger: { type: "post", priority: 5 },
                         sessionSummary: { type: "post", priority: 15 },
@@ -829,28 +387,28 @@ All path violations will be automatically detected and blocked.
                 }
                 // Generate automated framework report if threshold met
                 const complexityScore = this.calculateComplexityScore(monitoringResults, context);
-                const reportPath = await this.generateFrameworkReport(complexityScore, context, sessionId);
+                const reportPath = await this.reporter.generateFrameworkReport(complexityScore, context, sessionId);
                 // Validate the generated report for hidden issues
                 if (reportPath) {
-                    await this.validateGeneratedReport(reportPath, "framework");
+                    await this.reporter.validateGeneratedReport(reportPath, "framework");
                 }
                 return result;
             }
             // Pipeline failed - analyze and attempt fixes
             await frameworkLogger.log("postprocessor", "ci-cd-pipeline-failed", "error", { jobId, action: "analyzing-issues" });
             const analysis = await this.failureAnalysisEngine.analyzeFailure(monitoringResult);
-            await frameworkLogger.log("-post-processor", "-analysis-complete-analysis-category-analysis-seve", "info", {
+            await frameworkLogger.log("postprocessor", "analysis-complete", "info", {
                 message: `🔍 Analysis complete: ${analysis.category} (${analysis.severity}) - ${analysis.rootCause}`,
             });
             const fixResult = await this.autoFixEngine.applyFixes(analysis, context);
             if (fixResult.success && fixResult.appliedFixes.length > 0) {
-                await frameworkLogger.log("-post-processor", "-fixresult-appliedfixes-length-fix-es-applied-succ", "success", {
+                await frameworkLogger.log("postprocessor", "fixes-applied", "success", {
                     message: `🔧 ${fixResult.appliedFixes.length} fix(es) applied successfully`,
                 });
                 // Validate that fixes resolve the issue
                 const validationPassed = await this.fixValidator.validateFixes(fixResult.appliedFixes, analysis, context);
                 if (validationPassed) {
-                    await frameworkLogger.log("-post-processor", "-fix-validation-passed-redeploying-", "success", { message: "✅ Fix validation passed - redeploying..." });
+                    await frameworkLogger.log("postprocessor", "fix-validation-passed", "success", { message: "✅ Fix validation passed - redeploying..." });
                     await this.redeployWithFixes(context, fixResult, jobId);
                     // Continue monitoring with next attempt
                     continue;
@@ -863,8 +421,8 @@ All path violations will be automatically detected and blocked.
             // Check if escalation is needed before retry
             const escalationResult = await this.escalationEngine.evaluateEscalation(context, attempts, "CI/CD pipeline failure", monitoringResults);
             if (escalationResult) {
-                await frameworkLogger.log("-post-processor", "-escalation-triggered-escalationresult-level-", "info", { message: `🚨 Escalation triggered: ${escalationResult.level}` });
-                await frameworkLogger.log("-post-processor", "-reason-escalationresult-reason-", "info", { message: `   Reason: ${escalationResult.reason}` });
+                await frameworkLogger.log("postprocessor", "escalation-triggered", "info", { message: `🚨 Escalation triggered: ${escalationResult.level}` });
+                await frameworkLogger.log("postprocessor", "escalation-reason", "info", { message: `   Reason: ${escalationResult.reason}` });
                 // For emergency/rollback levels, stop the loop
                 if (escalationResult.level === "emergency" ||
                     escalationResult.level === "rollback") {
@@ -898,10 +456,10 @@ All path violations will be automatically detected and blocked.
      * Redeploy after applying fixes using the RedeployCoordinator
      */
     async redeployWithFixes(context, fixResult, jobId) {
-        await frameworkLogger.log("-post-processor", "-executing-redeployment-with-fixes-", "info", { message: "🔄 Executing redeployment with fixes..." });
+        await frameworkLogger.log("postprocessor", "redeploy-start", "info", { message: "🔄 Executing redeployment with fixes..." });
         const redeployResult = await this.redeployCoordinator.executeRedeploy(context, fixResult);
         if (redeployResult.success) {
-            await frameworkLogger.log("-post-processor", "-redeployment-successful-redeployresult-deployment", "success", {
+            await frameworkLogger.log("postprocessor", "redeploy-success", "success", {
                 message: `✅ Redeployment successful: ${redeployResult.deploymentId}`,
             });
         }
@@ -921,7 +479,7 @@ All path violations will be automatically detected and blocked.
      * Escalate to manual intervention
      */
     async escalateToManualIntervention(context, monitoringResult, attempts) {
-        await frameworkLogger.log("-post-processor", "-escalating-to-manual-intervention-", "info", { message: "🚨 Escalating to manual intervention" });
+        await frameworkLogger.log("postprocessor", "escalate-manual", "info", { message: "🚨 Escalating to manual intervention" });
         // Create detailed incident report
         const report = {
             commitSha: context.commitSha,
@@ -938,7 +496,7 @@ All path violations will be automatically detected and blocked.
         // Store escalation details
         await this.stateManager.set(`escalation:${context.commitSha}`, report);
         // TODO: Send notifications to development team
-        await frameworkLogger.log("-post-processor", "-escalation-report-created-report", "info", { message: "📋 Escalation report created:", report });
+        await frameworkLogger.log("postprocessor", "escalation-report-created", "info", { message: "📋 Escalation report created", report });
     }
     /**
      * Wait before retry with exponential backoff
@@ -946,7 +504,7 @@ All path violations will be automatically detected and blocked.
     async waitBeforeRetry(attempt) {
         const baseDelay = this.config.retryDelay || 30000; // 30 seconds
         const delay = baseDelay * Math.pow(2, attempt - 1);
-        await frameworkLogger.log("-post-processor", "-waiting-delay-ms-before-retry-attempt-attempt-1-", "info", { message: `⏳ Waiting ${delay}ms before retry attempt ${attempt + 1}` });
+        await frameworkLogger.log("postprocessor", "wait-before-retry", "info", { message: `⏳ Waiting ${delay}ms before retry attempt ${attempt + 1}` });
         await new Promise((resolve) => setTimeout(resolve, delay));
     }
     /**
@@ -959,54 +517,6 @@ All path violations will be automatically detected and blocked.
             monitoringStatus: await this.monitoringEngine.getStatus(),
         };
     }
-    /**
-     * Call appropriate agent/skill to fix architectural compliance violations
-     */
-    async callAgentForArchitecturalFix(violationType, agentName, skillName, context, violationMessage) {
-        try {
-            await frameworkLogger.log("-post-processor", "-calling-agentname-skillname-to-fix-violationtype-", "info", {
-                message: `🔧 Calling ${agentName} (${skillName}) to fix: ${violationType}`,
-            });
-            // Call the skill invocation MCP server to delegate to the appropriate agent/skill
-            const result = await mcpClientManager.callServerTool("skill-invocation", "invoke-skill", {
-                skillName: skillName,
-                toolName: "analyze_code_quality", // Default tool for analysis
-                args: {
-                    code: context.files || [],
-                    language: "typescript",
-                    context: {
-                        violationType,
-                        message: violationMessage,
-                        commitSha: context.commitSha,
-                        repository: context.repository,
-                        branch: context.branch,
-                        author: context.author,
-                    },
-                },
-            });
-            await frameworkLogger.log("-post-processor", "-agent-agentname-completed-fix-attempt-for-violati", "success", {
-                message: `✅ Agent ${agentName} completed fix attempt for ${violationType}`,
-            });
-            // Check if the fix was successful by re-running the validation
-            const fixed = await this.revalidateAfterFix(violationType, context);
-            if (fixed) {
-                await frameworkLogger.log("-post-processor", "-violationtype-violation-fixed-by-agentname-", "info", { message: `🎉 ${violationType} violation fixed by ${agentName}` });
-                return true;
-            }
-            else {
-                await frameworkLogger.log("-post-processor", "-violationtype-violation-not-fixed-by-agentname-", "error", {
-                    message: `❌ ${violationType} violation not fixed by ${agentName}`,
-                });
-                return false;
-            }
-        }
-        catch (error) {
-            await frameworkLogger.log("-post-processor", "-failed-to-call-agent-agentname-for-violationtype-", "error", {
-                message: `❌ Failed to call agent ${agentName} for ${violationType}: ${error instanceof Error ? error.message : String(error)}`,
-            });
-            return false;
-        }
-    }
     /**
      * Calculate complexity score for automated report triggering
      */
@@ -1021,28 +531,4 @@ All path violations will be automatically detected and blocked.
         // Total score (0-100)
         return Math.min(fileScore + monitoringScore, 100);
     }
-    /**
-     * Revalidate after agent fix attempt
-     */
-    async revalidateAfterFix(violationType, context) {
-        switch (violationType) {
-            case "checkSystemIntegrity":
-                const integrityCheck = await this.checkSystemIntegrity(context);
-                return integrityCheck.passed;
-            case "checkIntegrationTesting":
-                const integrationCheck = await this.checkIntegrationTesting(context);
-                return integrationCheck.passed;
-            case "checkPathResolution":
-                const pathCheck = await this.checkPathResolution(context);
-                return pathCheck.passed;
-            case "checkFeatureCompleteness":
-                const completenessCheck = await this.checkFeatureCompleteness(context);
-                return completenessCheck.passed;
-            case "checkPathAnalysisGuidelines":
-                const guidelinesCheck = await this.checkPathAnalysisGuidelines(context);
-                return guidelinesCheck.passed;
-            default:
-                return false;
-        }
-    }
 }