mcp-ai-agent-guidelines/dist/tools/design/services/phase-management.service.js

A comprehensive Model Context Protocol server providing advanced tools, resources, and prompts for implementing AI agent best practices

// Phase Management Service - Handles design phase workflow operations
import { sessionNotFoundError, validationError, } from "../../shared/error-factory.js";
import { confirmationModule } from "../confirmation-module.js";
import { coverageEnforcer } from "../coverage-enforcer.js";
import { designPhaseWorkflow } from "../design-phase-workflow.js";
import { pivotModule } from "../pivot-module.js";
class PhaseManagementServiceImpl {
    async advancePhase(sessionId, content, targetPhaseId) {
        const sessionState = designPhaseWorkflow.getSession(sessionId);
        if (!sessionState) {
            throw sessionNotFoundError(sessionId);
        }
        // Validate current phase if content is provided
        let validationResults;
        if (content) {
            validationResults = await confirmationModule.confirmPhaseCompletion({
                sessionState,
                phaseId: sessionState.currentPhase,
                content,
                autoAdvance: false,
            });
            if (!validationResults.canProceed) {
                throw validationError("Current phase validation failed", {
                    sessionId,
                    currentPhase: sessionState.currentPhase,
                    recommendations: validationResults.recommendations,
                });
            }
        }
        // Advance to next phase
        const workflowResult = await designPhaseWorkflow.executeWorkflow({
            action: "advance",
            sessionId,
            phaseId: targetPhaseId,
            content,
        });
        // Check for pivot recommendation
        let pivotDecision;
        if (content) {
            pivotDecision = await pivotModule.evaluatePivotNeed({
                sessionState: workflowResult.sessionState,
                currentContent: content,
            });
        }
        return {
            success: workflowResult.success,
            sessionId,
            currentPhase: workflowResult.currentPhase,
            nextPhase: workflowResult.nextPhase,
            coverage: validationResults?.coverage,
            status: workflowResult.success ? "advanced" : "failed",
            message: workflowResult.message,
            recommendations: [
                ...workflowResult.recommendations,
                ...(pivotDecision?.triggered
                    ? [`⚠️ ${pivotDecision.recommendation}`]
                    : []),
            ],
            artifacts: workflowResult.artifacts,
            validationResults,
            pivotDecision,
        };
    }
    async validatePhase(sessionId, phaseId, content) {
        const sessionState = designPhaseWorkflow.getSession(sessionId);
        if (!sessionState) {
            throw sessionNotFoundError(sessionId);
        }
        // Perform comprehensive validation
        const validationResults = await confirmationModule.confirmPhaseCompletion({
            sessionState,
            phaseId,
            content,
            strictMode: true,
        });
        const coverageResult = await coverageEnforcer.enforceCoverage({
            sessionState,
            content,
            enforceThresholds: true,
        });
        const recommendations = [
            ...validationResults.recommendations,
            ...coverageResult.recommendations,
        ];
        if (!validationResults.passed || !coverageResult.passed) {
            throw validationError(`Phase ${phaseId} validation failed`, {
                sessionId,
                phaseId,
                recommendations,
                coverage: coverageResult.coverage,
            });
        }
        return {
            success: true,
            sessionId,
            currentPhase: sessionState.currentPhase,
            coverage: validationResults.coverage,
            status: "validated",
            message: `Phase ${phaseId} validation successful`,
            recommendations: [...new Set(recommendations)], // Remove duplicates
            artifacts: [],
            validationResults,
            coverageReport: coverageResult,
        };
    }
    async getPhaseGuidance(_sessionState, phaseId) {
        return [
            `Focus on ${phaseId} key criteria`,
            "Engage stakeholders",
            "Document decisions",
        ];
    }
    async getPhaseSequence() {
        return designPhaseWorkflow.getPhaseSequence();
    }
}
// Export singleton instance
export const phaseManagementService = new PhaseManagementServiceImpl();
// Module Implementation Status Sentinel
export const IMPLEMENTATION_STATUS = "IMPLEMENTED";
//# sourceMappingURL=phase-management.service.js.map