0xray 4.0.12 → 4.0.13

package/dist/postprocessor/PostProcessor.js

@@ -1,1053 +0,0 @@
-/**
- * 0xRay Post-Processor - Core Infrastructure
- *
- * Automated CI/CD loop orchestration: commit → push → monitor → fix → redeploy → monitor
- * Provides systematic error prevention and deployment automation.
- *
- * @since 2026-01-13
- */
-import * as path from "path";
-import { frameworkLogger } from "../core/framework-logger.js";
-import { featuresConfigLoader } from "../core/features-config.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 { 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 { RegressionAnalysisService } from "./services/RegressionAnalysisService.js";
-import { SelfProposalEngine } from "./metamorphosis/SelfProposalEngine.js";
-export class PostProcessor {
-    stateManager;
-    sessionMonitor;
-    config;
-    monitoringEngine;
-    failureAnalysisEngine;
-    autoFixEngine;
-    fixValidator;
-    reportValidator;
-    regressionAnalysisService;
-    redeployCoordinator;
-    escalationEngine;
-    successHandler;
-    triggers;
-    metamorphosisEngines;
-    constructor(stateManager, sessionMonitor = null, config = {}) {
-        this.stateManager = stateManager;
-        this.sessionMonitor = sessionMonitor;
-        this.config = { ...defaultConfig, ...config };
-        // Initialize monitoring engine
-        this.monitoringEngine = new PostProcessorMonitoringEngine(this.stateManager, this.sessionMonitor || undefined);
-        // Initialize failure analysis and auto-fix engines
-        this.failureAnalysisEngine = new FailureAnalysisEngine();
-        this.autoFixEngine = new AutoFixEngine(this.config.autoFix.confidenceThreshold);
-        this.fixValidator = new FixValidator();
-        this.reportValidator = new ReportContentValidator();
-        this.regressionAnalysisService = new RegressionAnalysisService();
-        // Initialize redeploy coordinator
-        this.redeployCoordinator = new RedeployCoordinator(this.config.redeploy);
-        // Initialize escalation and success handlers
-        this.escalationEngine = new EscalationEngine(this.config.escalation);
-        this.successHandler = new SuccessHandler(this.config.success);
-        this.metamorphosisEngines = [new SelfProposalEngine({ projectRoot: process.cwd() })];
-        // Initialize trigger mechanisms
-        this.triggers = {
-            gitHook: new GitHookTrigger(this),
-            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() {
-        try {
-            const config = featuresConfigLoader.loadConfig();
-            return config.processors ?? {};
-        }
-        catch (error) {
-            frameworkLogger.log("postprocessor", "processor-config-load-failed", "info", {
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-        return {};
-    }
-    /**
-     * Initialize the post-processor system
-     */
-    async initialize() {
-        await frameworkLogger.log("-post-processor", "-initializing-xray-post-processor-", "info", { message: "🚀 Initializing 0xRay Post-Processor..." });
-        // Initialize monitoring
-        if (this.config.monitoring.enabled) {
-            await this.monitoringEngine.initialize();
-            // Postprocessor initialization - removed unnecessary startup logging
-        }
-        // Initialize triggers
-        if (this.config.triggers.gitHooks) {
-            await this.triggers.gitHook.initialize();
-            // Git hooks initialization - removed unnecessary startup logging
-        }
-        if (this.config.triggers.webhooks) {
-            await this.triggers.webhook.initialize();
-            // Webhook triggers initialization - removed unnecessary startup logging
-        }
-        if (this.config.triggers.api) {
-            await this.triggers.api.initialize();
-        }
-        try {
-            const { memoryMonitor } = await import("../monitoring/memory-monitor.js");
-            memoryMonitor.start();
-            frameworkLogger.log("postprocessor", "memory-monitor-started", "info", {
-                message: "Memory monitor auto-started",
-            });
-        }
-        catch {
-            frameworkLogger.log("postprocessor", "memory-monitor-unavailable", "info", {
-                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.xrayStateManager;
-        const postProcessor = globalThis.xrayPostProcessor;
-        if (!stateManager) {
-            try {
-                const { XrayStateManager } = await import("../state/state-manager.js");
-                const tempStateManager = new XrayStateManager();
-                globalThis.xrayStateManager = 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.xrayPathResolver;
-        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.XRAY_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",
-        };
-    }
-    /**
-     * Execute the complete post-processor loop
-     */
-    async executePostProcessorLoop(context) {
-        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", {
-            message: `🔄 Starting post-processor loop for commit: ${context.commitSha}`,
-        });
-        // Validate architectural compliance before processing
-        const compliancePassed = await this.validateArchitecturalCompliance(context);
-        if (!compliancePassed) {
-            await frameworkLogger.log("-post-processor", "-architectural-compliance-validation-failed-blocki", "error", {
-                message: "❌ Architectural compliance validation failed - blocking post-processing",
-            });
-            return {
-                success: false,
-                commitSha: context.commitSha,
-                sessionId: `validation-${context.commitSha}`,
-                attempts: 0,
-                error: "Architectural compliance validation failed",
-            };
-        }
-        // 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);
-        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 PRE_PROCESSOR_DEFAULTS = {
-                preValidate: { type: "pre", priority: 10 },
-                codexCompliance: { type: "pre", priority: 20 },
-                testAutoCreation: { type: "pre", priority: 22 },
-                versionCompliance: { type: "pre", priority: 25 },
-                errorBoundary: { type: "pre", priority: 30 },
-                agentsMdValidation: { type: "pre", priority: 35 },
-            };
-            for (const [name, def] of Object.entries(PRE_PROCESSOR_DEFAULTS)) {
-                const enabled = processorConfig[name]?.enabled ?? true;
-                processorManager.registerProcessor({ name, type: def.type, priority: def.priority, enabled });
-            }
-            processorManager.registerProcessor({ name: "stateValidation", type: "post", priority: 130, enabled: true });
-            const POST_PROCESSOR_MAP = {
-                storytellingTrigger: { type: "post", priority: 5 },
-                sessionSummary: { type: "post", priority: 15 },
-                testExecution: { type: "post", priority: 40 },
-                regressionTesting: { type: "post", priority: 50 },
-                inferenceImprovement: { type: "post", priority: 60 },
-            };
-            const postConfig = processorConfig.post_processors;
-            const postEnabled = postConfig?.enabled !== false;
-            const postOrder = postConfig?.priority_order || Object.keys(POST_PROCESSOR_MAP);
-            if (postEnabled) {
-                for (let i = 0; i < postOrder.length; i++) {
-                    const name = postOrder[i];
-                    const def = POST_PROCESSOR_MAP[name];
-                    if (def) {
-                        const cfg = processorConfig;
-                        processorManager.registerProcessor({
-                            name,
-                            type: def.type,
-                            priority: 100 + (i * 10),
-                            enabled: cfg[name]?.enabled ?? true,
-                        });
-                    }
-                }
-            }
-            // Initialize all registered processors
-            await processorManager.initializeProcessors();
-            const complianceResult = await processorManager.executeCodexCompliance(processorContext);
-            // FIX #1: Run test auto-creation for ALL new files, NOT just non-compliant ones
-            // Iterate over each file and create tests for new TypeScript files
-            if (context.files && context.files.length > 0) {
-                for (const filePath of context.files) {
-                    // Only process TypeScript source files (not test files)
-                    if (filePath.endsWith(".ts") && !filePath.endsWith(".test.ts")) {
-                        try {
-                            // 1. First create the test
-                            await processorManager.executeProcessor("testAutoCreation", {
-                                tool: "write",
-                                operation: "commit",
-                                args: {
-                                    filePath: filePath, // Pass filePath in args structure
-                                },
-                                directory: process.cwd(),
-                            });
-                            // 2. Then run the generated test
-                            await processorManager.executeProcessor("testExecution", {
-                                tool: "write",
-                                operation: "commit",
-                                args: {
-                                    filePath: filePath,
-                                },
-                                directory: process.cwd(),
-                            });
-                        }
-                        catch (testError) {
-                            // Non-blocking - log but continue
-                            await frameworkLogger.log("-post-processor", "-test-auto-creation-failed", "info", {
-                                message: `Test auto-creation failed for ${filePath}: ${testError}`,
-                            });
-                        }
-                    }
-                }
-            }
-            if (!complianceResult.compliant) {
-                await frameworkLogger.log("codex-compliance", "validation-failed", "error", {
-                    jobId,
-                    commitSha: context.commitSha,
-                    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", {
-                    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", {
-                message: "⚠️ Codex compliance check failed - continuing with commit",
-            });
-        }
-        try {
-            // Initialize session tracking
-            await this.stateManager.set(`postprocessor:${sessionId}`, {
-                status: "running",
-                startTime,
-                context,
-                attempts: 0,
-            });
-            // Execute the monitoring → analysis → fix → redeploy loop
-            const result = await this.executeMonitoringLoop(context, sessionId, jobId);
-            // Update final status
-            await this.stateManager.set(`postprocessor:${sessionId}`, {
-                ...result,
-                endTime: Date.now(),
-                duration: Date.now() - startTime,
-            });
-            await frameworkLogger.log("-post-processor", "-post-processor-loop-completed-result-success-succ", "success", {
-                message: `✅ Post-processor loop completed: ${result.success ? "SUCCESS" : "FAILED"}`,
-            });
-            return result;
-        }
-        catch (error) {
-            await frameworkLogger.log("postprocessor", "post-processor-loop-failed", "error", { error: String(error) });
-            const failureResult = {
-                success: false,
-                commitSha: context.commitSha,
-                sessionId,
-                error: error instanceof Error ? error.message : String(error),
-                attempts: 1,
-                monitoringResults: [],
-                fixesApplied: [],
-            };
-            await this.stateManager.set(`postprocessor:${sessionId}`, {
-                ...failureResult,
-                endTime: Date.now(),
-                duration: Date.now() - startTime,
-            });
-            return failureResult;
-        }
-    }
-    /**
-     * Execute the monitoring loop until success or max attempts
-     */
-    async executeMonitoringLoop(context, sessionId, jobId) {
-        let attempts = 0;
-        const maxAttempts = this.config.maxAttempts || 3;
-        const monitoringResults = [];
-        while (attempts < maxAttempts) {
-            attempts++;
-            await frameworkLogger.log("-post-processor", "-monitoring-attempt-attempts-maxattempts-for-conte", "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" });
-                const result = {
-                    success: true,
-                    commitSha: context.commitSha,
-                    sessionId,
-                    attempts,
-                    monitoringResults,
-                };
-                // Handle successful completion
-                await this.successHandler.handleSuccess(context, result, monitoringResults);
-                for (const engine of this.metamorphosisEngines) {
-                    try {
-                        await engine.onPhase('post-process-complete', { context, result, monitoringResults });
-                    }
-                    catch (metaErr) {
-                        await frameworkLogger.log('-post-processor', 'self-proposal-phase-error', 'warning', { error: String(metaErr) });
-                    }
-                }
-                // AGENTS.md auto-update with smart triggers
-                // Only updates when agent-related files have changed
-                const agentChangePatterns = [
-                    /\.opencode\/agents\//,
-                    /\/agents\//,
-                    /AGENTS\.md$/,
-                ];
-                const changedFiles = context.files || [];
-                const hasAgentChanges = changedFiles.some((file) => agentChangePatterns.some((pattern) => pattern.test(file)));
-                if (hasAgentChanges || process.env.ENABLE_AGENTS_AUTO_UPDATE === "always") {
-                    try {
-                        const { librarianAgentsUpdater } = await import("../agents/librarian-agents-updater.js");
-                        activity.script("docs-sync-started", "AGENTS.md auto-sync triggered", {
-                            reason: hasAgentChanges ? "agent-files-changed" : "always-enabled",
-                            changedFiles: changedFiles.filter((f) => agentChangePatterns.some((p) => p.test(f))).length
-                        });
-                        await librarianAgentsUpdater.updateAgentsMd(process.cwd());
-                        activity.success("development", "docs-sync-complete", "AGENTS.md auto-sync completed");
-                        await frameworkLogger.log("postprocessor", "agents-md-auto-updated", "info", {
-                            message: "AGENTS.md updated due to agent-related changes",
-                            changedFiles: changedFiles.filter((f) => agentChangePatterns.some((p) => p.test(f))).length
-                        });
-                    }
-                    catch (error) {
-                        await frameworkLogger.log("postprocessor", "agents-md-update-failed", "info", { message: `AGENTS.md auto-update failed: ${error}` });
-                    }
-                }
-                // Regression analysis check
-                try {
-                    const regressionDecision = await this.regressionAnalysisService.shouldAnalyze(context);
-                    if (regressionDecision.required) {
-                        await frameworkLogger.log("postprocessor", "regression-analysis-required", "info", {
-                            reason: regressionDecision.reason,
-                            agents: regressionDecision.agents,
-                            depth: regressionDecision.depth,
-                        });
-                        await this.regressionAnalysisService.invokeAnalysis(context, regressionDecision);
-                    }
-                }
-                catch (regressionError) {
-                    await frameworkLogger.log("postprocessor", "regression-analysis-failed", "warning", {
-                        error: String(regressionError),
-                    });
-                }
-                // Execute post-processors (storytelling, session summary, test execution, regression testing)
-                try {
-                    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 POST_MAP = {
-                        storytellingTrigger: { type: "post", priority: 5 },
-                        sessionSummary: { type: "post", priority: 15 },
-                        testExecution: { type: "post", priority: 40 },
-                        regressionTesting: { type: "post", priority: 50 },
-                        inferenceImprovement: { type: "post", priority: 60 },
-                    };
-                    const postCfg = postProcessorConfig.post_processors;
-                    const postOrder = postCfg?.priority_order || Object.keys(POST_MAP);
-                    for (let i = 0; i < postOrder.length; i++) {
-                        const name = postOrder[i];
-                        const def = POST_MAP[name];
-                        if (def && (postCfg?.enabled !== false)) {
-                            pm.registerProcessor({ name, type: def.type, priority: 100 + i * 10, enabled: true });
-                        }
-                    }
-                    await pm.initializeProcessors();
-                    const postResults = await pm.executePostProcessors("commit", {
-                        files: context.files,
-                        commitSha: context.commitSha,
-                        operation: context.operation,
-                        sessionDurationMinutes: (Date.now() - context.startTime) / 60000,
-                    }, []);
-                    const triggeredStorytelling = postResults.find((r) => r.processorName === "storytellingTrigger" && r.success);
-                    if (triggeredStorytelling) {
-                        await frameworkLogger.log("postprocessor", "storytelling-trigger-activated", "info", {
-                            result: triggeredStorytelling.data,
-                        });
-                    }
-                }
-                catch (postError) {
-                    await frameworkLogger.log("postprocessor", "post-processors-failed", "warning", {
-                        error: String(postError),
-                    });
-                }
-                // Generate automated framework report if threshold met
-                const complexityScore = this.calculateComplexityScore(monitoringResults, context);
-                const reportPath = await this.generateFrameworkReport(complexityScore, context, sessionId);
-                // Validate the generated report for hidden issues
-                if (reportPath) {
-                    await this.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", {
-                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", {
-                    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 this.redeployWithFixes(context, fixResult, jobId);
-                    // Continue monitoring with next attempt
-                    continue;
-                }
-                else {
-                    await frameworkLogger.log("postprocessor", "fix-validation-failed", "error", { jobId, action: "rolling-back" });
-                    await this.fixValidator.rollbackFixes(fixResult.appliedFixes);
-                }
-            }
-            // 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}` });
-                // For emergency/rollback levels, stop the loop
-                if (escalationResult.level === "emergency" ||
-                    escalationResult.level === "rollback") {
-                    return {
-                        success: false,
-                        commitSha: context.commitSha,
-                        sessionId,
-                        attempts,
-                        monitoringResults,
-                        fixesApplied: fixResult?.appliedFixes || [],
-                        error: `Escalation triggered: ${escalationResult.reason}`,
-                    };
-                }
-            }
-            // Wait before retry (only if not escalated to emergency/rollback)
-            await this.waitBeforeRetry(attempts);
-        }
-        // Max attempts exceeded - final escalation
-        const finalEscalation = await this.escalationEngine.evaluateEscalation(context, attempts, "Max attempts exceeded - deployment failed", monitoringResults);
-        return {
-            success: false,
-            commitSha: context.commitSha,
-            sessionId,
-            attempts,
-            monitoringResults,
-            fixesApplied: [],
-            error: "Max attempts exceeded",
-        };
-    }
-    /**
-     * 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..." });
-        const redeployResult = await this.redeployCoordinator.executeRedeploy(context, fixResult);
-        if (redeployResult.success) {
-            await frameworkLogger.log("-post-processor", "-redeployment-successful-redeployresult-deployment", "success", {
-                message: `✅ Redeployment successful: ${redeployResult.deploymentId}`,
-            });
-        }
-        else {
-            await frameworkLogger.log("postprocessor", "redeployment-failed", "error", { jobId, error: redeployResult.error });
-            throw new Error(`Redeployment failed: ${redeployResult.error}`);
-        }
-    }
-    /**
-     * Attempt to apply automatic fixes
-     */
-    async attemptAutoFix(analysis, context) {
-        // Placeholder for auto-fix - disabled for now
-        return { success: false, requiresManualIntervention: true };
-    }
-    /**
-     * Escalate to manual intervention
-     */
-    async escalateToManualIntervention(context, monitoringResult, attempts) {
-        await frameworkLogger.log("-post-processor", "-escalating-to-manual-intervention-", "info", { message: "🚨 Escalating to manual intervention" });
-        // Create detailed incident report
-        const report = {
-            commitSha: context.commitSha,
-            attempts,
-            monitoringResult,
-            timestamp: new Date().toISOString(),
-            recommendations: [
-                "Review CI/CD pipeline logs for detailed error information",
-                "Check failed test outputs and error messages",
-                "Verify recent code changes for potential issues",
-                "Consider manual fixes or rollback if necessary",
-            ],
-        };
-        // 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 });
-    }
-    /**
-     * Wait before retry with exponential backoff
-     */
-    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 new Promise((resolve) => setTimeout(resolve, delay));
-    }
-    /**
-     * Get post-processor status
-     */
-    async getStatus() {
-        return {
-            activeSessions: 0, // Placeholder
-            config: this.config,
-            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
-     */
-    calculateComplexityScore(monitoringResults, context) {
-        // Simple complexity calculation based on file count and monitoring results
-        const fileCount = context.files?.length || 0;
-        const monitoringIssues = monitoringResults?.length || 0;
-        // Base score from file count (max 50 points)
-        const fileScore = Math.min(fileCount * 2, 50);
-        // Additional score from monitoring issues (max 30 points)
-        const monitoringScore = Math.min(monitoringIssues * 5, 30);
-        // 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;
-        }
-    }
-}