sdd-mcp-server 1.0.0

package/dist/domain/templates/index.d.ts

@@ -0,0 +1,158 @@
+export interface TemplateData {
+    readonly [key: string]: unknown;
+}
+export interface TemplateContext {
+    readonly project: {
+        readonly name: string;
+        readonly description?: string;
+        readonly id: string;
+        readonly basePath: string;
+    };
+    readonly timestamp: Date;
+    readonly user: {
+        readonly name?: string;
+        readonly email?: string;
+    };
+    readonly metadata: Record<string, unknown>;
+}
+export interface TemplateRendererPort {
+    compile(template: string, name?: string): Promise<CompiledTemplate>;
+    render(templateName: string, data: TemplateData, context: TemplateContext): Promise<string>;
+    renderString(template: string, data: TemplateData, context: TemplateContext): Promise<string>;
+    registerHelper(name: string, helper: (...args: unknown[]) => unknown): void;
+    registerPartial(name: string, template: string): Promise<void>;
+    clearCache(): void;
+}
+export interface CompiledTemplate {
+    readonly name: string;
+    readonly template: string;
+    readonly compiledAt: Date;
+    render(data: TemplateData, context: TemplateContext): string;
+}
+export interface Template {
+    readonly id: string;
+    readonly name: string;
+    readonly category: TemplateCategory;
+    readonly description: string;
+    readonly template: string;
+    readonly variables: TemplateVariable[];
+    readonly version: string;
+    readonly author?: string;
+    readonly tags: string[];
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+}
+export interface TemplateVariable {
+    readonly name: string;
+    readonly type: TemplateVariableType;
+    readonly description: string;
+    readonly required: boolean;
+    readonly defaultValue?: unknown;
+    readonly validation?: TemplateValidation;
+}
+export interface TemplateValidation {
+    readonly pattern?: string;
+    readonly minLength?: number;
+    readonly maxLength?: number;
+    readonly minimum?: number;
+    readonly maximum?: number;
+    readonly enum?: unknown[];
+}
+export declare enum TemplateCategory {
+    SPECIFICATION = "specification",
+    REQUIREMENTS = "requirements",
+    DESIGN = "design",
+    TASKS = "tasks",
+    STEERING = "steering",
+    CONFIG = "config",
+    DOCUMENTATION = "documentation",
+    CODE = "code"
+}
+export declare enum TemplateVariableType {
+    STRING = "string",
+    NUMBER = "number",
+    BOOLEAN = "boolean",
+    ARRAY = "array",
+    OBJECT = "object",
+    DATE = "date"
+}
+export interface TemplateManagerPort {
+    getTemplate(id: string): Promise<Template | null>;
+    getTemplatesByCategory(category: TemplateCategory): Promise<Template[]>;
+    searchTemplates(query: string, tags?: string[]): Promise<Template[]>;
+    createTemplate(template: Omit<Template, 'id' | 'createdAt' | 'updatedAt'>): Promise<Template>;
+    updateTemplate(id: string, updates: Partial<Template>): Promise<Template>;
+    deleteTemplate(id: string): Promise<void>;
+    validateTemplate(template: string, variables: TemplateVariable[]): Promise<TemplateValidationResult>;
+    getAllTemplates(): Promise<Template[]>;
+}
+export interface TemplateValidationResult {
+    readonly isValid: boolean;
+    readonly errors: TemplateValidationError[];
+    readonly warnings: TemplateValidationWarning[];
+}
+export interface TemplateValidationError {
+    readonly message: string;
+    readonly line?: number;
+    readonly column?: number;
+    readonly variable?: string;
+}
+export interface TemplateValidationWarning {
+    readonly message: string;
+    readonly line?: number;
+    readonly column?: number;
+    readonly suggestion?: string;
+}
+export interface FileGeneratorPort {
+    generateFile(filePath: string, template: string, data: TemplateData, context: TemplateContext, options?: FileGenerationOptions): Promise<FileGenerationResult>;
+    generateDirectory(dirPath: string, structure: DirectoryStructure, context: TemplateContext, options?: FileGenerationOptions): Promise<DirectoryGenerationResult>;
+    validatePath(path: string): Promise<PathValidationResult>;
+    backupFile(filePath: string): Promise<string>;
+    restoreBackup(backupPath: string, originalPath: string): Promise<void>;
+    cleanupBackups(olderThan: Date): Promise<string[]>;
+}
+export interface FileGenerationOptions {
+    readonly backup: boolean;
+    readonly overwrite: boolean;
+    readonly createDirectories: boolean;
+    readonly permissions?: string;
+    readonly atomic: boolean;
+}
+export interface FileGenerationResult {
+    readonly filePath: string;
+    readonly success: boolean;
+    readonly backupPath?: string;
+    readonly bytesWritten: number;
+    readonly error?: string;
+    readonly warnings: string[];
+}
+export interface DirectoryStructure {
+    readonly files: DirectoryFile[];
+    readonly subdirectories: Record<string, DirectoryStructure>;
+}
+export interface DirectoryFile {
+    readonly name: string;
+    readonly template: string;
+    readonly data: TemplateData;
+}
+export interface DirectoryGenerationResult {
+    readonly dirPath: string;
+    readonly success: boolean;
+    readonly filesGenerated: FileGenerationResult[];
+    readonly directoriesCreated: string[];
+    readonly errors: string[];
+    readonly warnings: string[];
+}
+export interface PathValidationResult {
+    readonly isValid: boolean;
+    readonly exists: boolean;
+    readonly isFile: boolean;
+    readonly isDirectory: boolean;
+    readonly permissions: PathPermissions;
+    readonly errors: string[];
+}
+export interface PathPermissions {
+    readonly read: boolean;
+    readonly write: boolean;
+    readonly execute: boolean;
+}

package/dist/domain/templates/index.js

@@ -0,0 +1,22 @@
+// Template engine interfaces and types
+export var TemplateCategory;
+(function (TemplateCategory) {
+    TemplateCategory["SPECIFICATION"] = "specification";
+    TemplateCategory["REQUIREMENTS"] = "requirements";
+    TemplateCategory["DESIGN"] = "design";
+    TemplateCategory["TASKS"] = "tasks";
+    TemplateCategory["STEERING"] = "steering";
+    TemplateCategory["CONFIG"] = "config";
+    TemplateCategory["DOCUMENTATION"] = "documentation";
+    TemplateCategory["CODE"] = "code";
+})(TemplateCategory || (TemplateCategory = {}));
+export var TemplateVariableType;
+(function (TemplateVariableType) {
+    TemplateVariableType["STRING"] = "string";
+    TemplateVariableType["NUMBER"] = "number";
+    TemplateVariableType["BOOLEAN"] = "boolean";
+    TemplateVariableType["ARRAY"] = "array";
+    TemplateVariableType["OBJECT"] = "object";
+    TemplateVariableType["DATE"] = "date";
+})(TemplateVariableType || (TemplateVariableType = {}));
+//# sourceMappingURL=index.js.map

package/dist/domain/templates/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/domain/templates/index.ts"],"names":[],"mappings":"AAAA,uCAAuC;AAqEvC,MAAM,CAAN,IAAY,gBASX;AATD,WAAY,gBAAgB;IAC1B,mDAA+B,CAAA;IAC/B,iDAA6B,CAAA;IAC7B,qCAAiB,CAAA;IACjB,mCAAe,CAAA;IACf,yCAAqB,CAAA;IACrB,qCAAiB,CAAA;IACjB,mDAA+B,CAAA;IAC/B,iCAAa,CAAA;AACf,CAAC,EATW,gBAAgB,KAAhB,gBAAgB,QAS3B;AAED,MAAM,CAAN,IAAY,oBAOX;AAPD,WAAY,oBAAoB;IAC9B,yCAAiB,CAAA;IACjB,yCAAiB,CAAA;IACjB,2CAAmB,CAAA;IACnB,uCAAe,CAAA;IACf,yCAAiB,CAAA;IACjB,qCAAa,CAAA;AACf,CAAC,EAPW,oBAAoB,KAApB,oBAAoB,QAO/B"}

package/dist/domain/types.d.ts

@@ -0,0 +1,115 @@
+export interface Project {
+    readonly id: string;
+    readonly name: string;
+    readonly path: string;
+    readonly phase: WorkflowPhase;
+    readonly metadata: ProjectMetadata;
+}
+export interface ProjectMetadata {
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly language: string;
+    readonly approvals: PhaseApprovals;
+}
+export interface PhaseApprovals {
+    readonly requirements: ApprovalStatus;
+    readonly design: ApprovalStatus;
+    readonly tasks: ApprovalStatus;
+}
+export interface ApprovalStatus {
+    readonly generated: boolean;
+    readonly approved: boolean;
+}
+export declare enum WorkflowPhase {
+    INIT = "init",
+    REQUIREMENTS = "requirements-generated",
+    DESIGN = "design-generated",
+    TASKS = "tasks-generated",
+    IMPLEMENTATION = "implementation-ready"
+}
+export declare enum WorkflowState {
+    PENDING = "pending",
+    IN_PROGRESS = "in-progress",
+    COMPLETED = "completed",
+    ERROR = "error"
+}
+export interface Requirement {
+    readonly id: string;
+    readonly title: string;
+    readonly objective: string;
+    readonly acceptanceCriteria: string[];
+}
+export interface Design {
+    readonly architecture: string;
+    readonly components: Component[];
+    readonly interfaces: Interface[];
+    readonly dataModels: DataModel[];
+}
+export interface Component {
+    readonly name: string;
+    readonly purpose: string;
+    readonly dependencies: string[];
+}
+export interface Interface {
+    readonly name: string;
+    readonly methods: Method[];
+}
+export interface Method {
+    readonly name: string;
+    readonly parameters: Parameter[];
+    readonly returnType: string;
+}
+export interface Parameter {
+    readonly name: string;
+    readonly type: string;
+    readonly required: boolean;
+}
+export interface DataModel {
+    readonly name: string;
+    readonly properties: Property[];
+}
+export interface Property {
+    readonly name: string;
+    readonly type: string;
+    readonly required: boolean;
+}
+export interface Task {
+    readonly id: string;
+    readonly title: string;
+    readonly description: string;
+    readonly requirements: string[];
+    readonly completed: boolean;
+}
+export interface QualityReport {
+    readonly score: TasteScore;
+    readonly issues: QualityIssue[];
+    readonly recommendations: string[];
+}
+export declare enum TasteScore {
+    GOOD = "good",
+    PASSABLE = "passable",
+    GARBAGE = "garbage"
+}
+export interface QualityIssue {
+    readonly type: IssueType;
+    readonly message: string;
+    readonly severity: IssueSeverity;
+    readonly location?: CodeLocation;
+}
+export declare enum IssueType {
+    COMPLEXITY = "complexity",
+    SPECIAL_CASE = "special-case",
+    DATA_STRUCTURE = "data-structure",
+    BREAKING_CHANGE = "breaking-change",
+    PRACTICALITY = "practicality"
+}
+export declare enum IssueSeverity {
+    ERROR = "error",
+    WARNING = "warning",
+    INFO = "info"
+}
+export interface CodeLocation {
+    readonly file: string;
+    readonly line: number;
+    readonly column: number;
+}

package/dist/domain/types.js

@@ -0,0 +1,37 @@
+// Core domain types for SDD workflow
+export var WorkflowPhase;
+(function (WorkflowPhase) {
+    WorkflowPhase["INIT"] = "init";
+    WorkflowPhase["REQUIREMENTS"] = "requirements-generated";
+    WorkflowPhase["DESIGN"] = "design-generated";
+    WorkflowPhase["TASKS"] = "tasks-generated";
+    WorkflowPhase["IMPLEMENTATION"] = "implementation-ready";
+})(WorkflowPhase || (WorkflowPhase = {}));
+export var WorkflowState;
+(function (WorkflowState) {
+    WorkflowState["PENDING"] = "pending";
+    WorkflowState["IN_PROGRESS"] = "in-progress";
+    WorkflowState["COMPLETED"] = "completed";
+    WorkflowState["ERROR"] = "error";
+})(WorkflowState || (WorkflowState = {}));
+export var TasteScore;
+(function (TasteScore) {
+    TasteScore["GOOD"] = "good";
+    TasteScore["PASSABLE"] = "passable";
+    TasteScore["GARBAGE"] = "garbage";
+})(TasteScore || (TasteScore = {}));
+export var IssueType;
+(function (IssueType) {
+    IssueType["COMPLEXITY"] = "complexity";
+    IssueType["SPECIAL_CASE"] = "special-case";
+    IssueType["DATA_STRUCTURE"] = "data-structure";
+    IssueType["BREAKING_CHANGE"] = "breaking-change";
+    IssueType["PRACTICALITY"] = "practicality";
+})(IssueType || (IssueType = {}));
+export var IssueSeverity;
+(function (IssueSeverity) {
+    IssueSeverity["ERROR"] = "error";
+    IssueSeverity["WARNING"] = "warning";
+    IssueSeverity["INFO"] = "info";
+})(IssueSeverity || (IssueSeverity = {}));
+//# sourceMappingURL=types.js.map

package/dist/domain/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/domain/types.ts"],"names":[],"mappings":"AAAA,qCAAqC;AA4BrC,MAAM,CAAN,IAAY,aAMX;AAND,WAAY,aAAa;IACvB,8BAAa,CAAA;IACb,wDAAuC,CAAA;IACvC,4CAA2B,CAAA;IAC3B,0CAAyB,CAAA;IACzB,wDAAuC,CAAA;AACzC,CAAC,EANW,aAAa,KAAb,aAAa,QAMxB;AAED,MAAM,CAAN,IAAY,aAKX;AALD,WAAY,aAAa;IACvB,oCAAmB,CAAA;IACnB,4CAA2B,CAAA;IAC3B,wCAAuB,CAAA;IACvB,gCAAe,CAAA;AACjB,CAAC,EALW,aAAa,KAAb,aAAa,QAKxB;AAgED,MAAM,CAAN,IAAY,UAIX;AAJD,WAAY,UAAU;IACpB,2BAAa,CAAA;IACb,mCAAqB,CAAA;IACrB,iCAAmB,CAAA;AACrB,CAAC,EAJW,UAAU,KAAV,UAAU,QAIrB;AASD,MAAM,CAAN,IAAY,SAMX;AAND,WAAY,SAAS;IACnB,sCAAyB,CAAA;IACzB,0CAA6B,CAAA;IAC7B,8CAAiC,CAAA;IACjC,gDAAmC,CAAA;IACnC,0CAA6B,CAAA;AAC/B,CAAC,EANW,SAAS,KAAT,SAAS,QAMpB;AAED,MAAM,CAAN,IAAY,aAIX;AAJD,WAAY,aAAa;IACvB,gCAAe,CAAA;IACf,oCAAmB,CAAA;IACnB,8BAAa,CAAA;AACf,CAAC,EAJW,aAAa,KAAb,aAAa,QAIxB"}

package/dist/domain/workflow/WorkflowStateMachine.d.ts

@@ -0,0 +1,62 @@
+import { WorkflowPhase, Project, PhaseApprovals } from '../types.js';
+export interface StateTransition {
+    from: WorkflowPhase;
+    to: WorkflowPhase;
+    condition: TransitionCondition;
+    action?: TransitionAction;
+}
+export interface TransitionCondition {
+    check: (project: Project) => boolean;
+    errorMessage: string;
+    requiredApprovals?: (keyof PhaseApprovals)[];
+}
+export interface TransitionAction {
+    execute: (project: Project) => Promise<Project>;
+    rollback?: (project: Project) => Promise<Project>;
+}
+export interface WorkflowAuditEntry {
+    id: string;
+    projectId: string;
+    timestamp: Date;
+    fromPhase: WorkflowPhase;
+    toPhase: WorkflowPhase;
+    triggeredBy: string;
+    success: boolean;
+    errorMessage?: string;
+    metadata?: Record<string, unknown>;
+}
+export declare class WorkflowStateMachine {
+    private readonly transitions;
+    private readonly auditLog;
+    constructor();
+    private initializeTransitions;
+    canTransition(project: Project, toPhase: WorkflowPhase): {
+        allowed: boolean;
+        reason?: string;
+        requiredApprovals?: string[];
+    };
+    executeTransition(project: Project, toPhase: WorkflowPhase, triggeredBy: string): Promise<{
+        success: boolean;
+        updatedProject?: Project;
+        error?: string;
+        auditEntry: WorkflowAuditEntry;
+    }>;
+    getValidTransitions(fromPhase: WorkflowPhase): WorkflowPhase[];
+    getNextPhase(currentPhase: WorkflowPhase): WorkflowPhase | null;
+    getPreviousPhase(currentPhase: WorkflowPhase): WorkflowPhase | null;
+    getAuditTrail(projectId: string): WorkflowAuditEntry[];
+    getPhaseProgress(project: Project): {
+        currentPhase: WorkflowPhase;
+        phaseIndex: number;
+        totalPhases: number;
+        progressPercentage: number;
+        nextPhase?: WorkflowPhase;
+        canProgress: boolean;
+        blockers?: string[];
+    };
+    validateWorkflowIntegrity(project: Project): {
+        isValid: boolean;
+        violations: string[];
+        recommendations: string[];
+    };
+}

package/dist/domain/workflow/WorkflowStateMachine.js

@@ -0,0 +1,286 @@
+// Domain model for SDD workflow state transitions
+import { WorkflowPhase } from '../types.js';
+export class WorkflowStateMachine {
+    transitions;
+    auditLog = [];
+    constructor() {
+        this.transitions = new Map();
+        this.initializeTransitions();
+    }
+    initializeTransitions() {
+        const transitions = [
+            // INIT -> REQUIREMENTS
+            {
+                from: WorkflowPhase.INIT,
+                to: WorkflowPhase.REQUIREMENTS,
+                condition: {
+                    check: () => true, // Always allow init -> requirements
+                    errorMessage: 'Cannot transition from INIT to REQUIREMENTS'
+                }
+            },
+            // REQUIREMENTS -> DESIGN
+            {
+                from: WorkflowPhase.REQUIREMENTS,
+                to: WorkflowPhase.DESIGN,
+                condition: {
+                    check: (project) => project.metadata.approvals.requirements.generated &&
+                        project.metadata.approvals.requirements.approved,
+                    errorMessage: 'Requirements must be generated and approved before design phase',
+                    requiredApprovals: ['requirements']
+                }
+            },
+            // DESIGN -> TASKS
+            {
+                from: WorkflowPhase.DESIGN,
+                to: WorkflowPhase.TASKS,
+                condition: {
+                    check: (project) => project.metadata.approvals.design.generated &&
+                        project.metadata.approvals.design.approved,
+                    errorMessage: 'Design must be generated and approved before tasks phase',
+                    requiredApprovals: ['design']
+                }
+            },
+            // TASKS -> IMPLEMENTATION
+            {
+                from: WorkflowPhase.TASKS,
+                to: WorkflowPhase.IMPLEMENTATION,
+                condition: {
+                    check: (project) => project.metadata.approvals.tasks.generated &&
+                        project.metadata.approvals.tasks.approved,
+                    errorMessage: 'Tasks must be generated and approved before implementation phase',
+                    requiredApprovals: ['tasks']
+                }
+            },
+            // Rollback transitions (always allowed for workflow corrections)
+            {
+                from: WorkflowPhase.REQUIREMENTS,
+                to: WorkflowPhase.INIT,
+                condition: {
+                    check: () => true,
+                    errorMessage: 'Cannot rollback from REQUIREMENTS to INIT'
+                }
+            },
+            {
+                from: WorkflowPhase.DESIGN,
+                to: WorkflowPhase.REQUIREMENTS,
+                condition: {
+                    check: () => true,
+                    errorMessage: 'Cannot rollback from DESIGN to REQUIREMENTS'
+                }
+            },
+            {
+                from: WorkflowPhase.TASKS,
+                to: WorkflowPhase.DESIGN,
+                condition: {
+                    check: () => true,
+                    errorMessage: 'Cannot rollback from TASKS to DESIGN'
+                }
+            },
+            {
+                from: WorkflowPhase.IMPLEMENTATION,
+                to: WorkflowPhase.TASKS,
+                condition: {
+                    check: () => true,
+                    errorMessage: 'Cannot rollback from IMPLEMENTATION to TASKS'
+                }
+            }
+        ];
+        // Group transitions by source phase
+        for (const transition of transitions) {
+            const key = transition.from;
+            if (!this.transitions.has(key)) {
+                this.transitions.set(key, []);
+            }
+            this.transitions.get(key).push(transition);
+        }
+    }
+    canTransition(project, toPhase) {
+        const fromPhase = project.phase;
+        const transitions = this.transitions.get(fromPhase) || [];
+        const validTransition = transitions.find(t => t.to === toPhase);
+        if (!validTransition) {
+            return {
+                allowed: false,
+                reason: `No valid transition from ${fromPhase} to ${toPhase}`
+            };
+        }
+        const conditionMet = validTransition.condition.check(project);
+        if (!conditionMet) {
+            return {
+                allowed: false,
+                reason: validTransition.condition.errorMessage,
+                requiredApprovals: validTransition.condition.requiredApprovals
+            };
+        }
+        return { allowed: true };
+    }
+    async executeTransition(project, toPhase, triggeredBy) {
+        const auditEntry = {
+            id: `audit_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            projectId: project.id,
+            timestamp: new Date(),
+            fromPhase: project.phase,
+            toPhase,
+            triggeredBy,
+            success: false
+        };
+        try {
+            const validation = this.canTransition(project, toPhase);
+            if (!validation.allowed) {
+                auditEntry.errorMessage = validation.reason;
+                this.auditLog.push(auditEntry);
+                return {
+                    success: false,
+                    error: validation.reason,
+                    auditEntry
+                };
+            }
+            const transitions = this.transitions.get(project.phase) || [];
+            const transition = transitions.find(t => t.to === toPhase);
+            let updatedProject = { ...project, phase: toPhase };
+            // Execute transition action if defined
+            if (transition?.action) {
+                updatedProject = await transition.action.execute(updatedProject);
+            }
+            // Update metadata
+            updatedProject.metadata = {
+                ...updatedProject.metadata,
+                updatedAt: new Date()
+            };
+            auditEntry.success = true;
+            auditEntry.metadata = {
+                previousPhase: project.phase,
+                newPhase: toPhase
+            };
+            this.auditLog.push(auditEntry);
+            return {
+                success: true,
+                updatedProject,
+                auditEntry
+            };
+        }
+        catch (error) {
+            auditEntry.errorMessage = error.message;
+            this.auditLog.push(auditEntry);
+            return {
+                success: false,
+                error: error.message,
+                auditEntry
+            };
+        }
+    }
+    getValidTransitions(fromPhase) {
+        const transitions = this.transitions.get(fromPhase) || [];
+        return transitions.map(t => t.to);
+    }
+    getNextPhase(currentPhase) {
+        const phaseOrder = [
+            WorkflowPhase.INIT,
+            WorkflowPhase.REQUIREMENTS,
+            WorkflowPhase.DESIGN,
+            WorkflowPhase.TASKS,
+            WorkflowPhase.IMPLEMENTATION
+        ];
+        const currentIndex = phaseOrder.indexOf(currentPhase);
+        if (currentIndex >= 0 && currentIndex < phaseOrder.length - 1) {
+            return phaseOrder[currentIndex + 1];
+        }
+        return null; // Already at final phase
+    }
+    getPreviousPhase(currentPhase) {
+        const phaseOrder = [
+            WorkflowPhase.INIT,
+            WorkflowPhase.REQUIREMENTS,
+            WorkflowPhase.DESIGN,
+            WorkflowPhase.TASKS,
+            WorkflowPhase.IMPLEMENTATION
+        ];
+        const currentIndex = phaseOrder.indexOf(currentPhase);
+        if (currentIndex > 0) {
+            return phaseOrder[currentIndex - 1];
+        }
+        return null; // Already at initial phase
+    }
+    getAuditTrail(projectId) {
+        return this.auditLog.filter(entry => entry.projectId === projectId);
+    }
+    getPhaseProgress(project) {
+        const phaseOrder = [
+            WorkflowPhase.INIT,
+            WorkflowPhase.REQUIREMENTS,
+            WorkflowPhase.DESIGN,
+            WorkflowPhase.TASKS,
+            WorkflowPhase.IMPLEMENTATION
+        ];
+        const currentIndex = phaseOrder.indexOf(project.phase);
+        const nextPhase = this.getNextPhase(project.phase);
+        let canProgress = false;
+        let blockers = [];
+        if (nextPhase) {
+            const validation = this.canTransition(project, nextPhase);
+            canProgress = validation.allowed;
+            if (!canProgress && validation.reason) {
+                blockers.push(validation.reason);
+            }
+        }
+        return {
+            currentPhase: project.phase,
+            phaseIndex: currentIndex,
+            totalPhases: phaseOrder.length,
+            progressPercentage: Math.round(((currentIndex + 1) / phaseOrder.length) * 100),
+            nextPhase: nextPhase || undefined,
+            canProgress,
+            blockers: blockers.length > 0 ? blockers : undefined
+        };
+    }
+    validateWorkflowIntegrity(project) {
+        const violations = [];
+        const recommendations = [];
+        const { approvals } = project.metadata;
+        // Check phase consistency with approvals
+        switch (project.phase) {
+            case WorkflowPhase.REQUIREMENTS:
+                if (!approvals.requirements.generated) {
+                    violations.push('Requirements phase active but requirements not generated');
+                }
+                break;
+            case WorkflowPhase.DESIGN:
+                if (!approvals.requirements.approved) {
+                    violations.push('Design phase active but requirements not approved');
+                }
+                if (!approvals.design.generated) {
+                    violations.push('Design phase active but design not generated');
+                }
+                break;
+            case WorkflowPhase.TASKS:
+                if (!approvals.design.approved) {
+                    violations.push('Tasks phase active but design not approved');
+                }
+                if (!approvals.tasks.generated) {
+                    violations.push('Tasks phase active but tasks not generated');
+                }
+                break;
+            case WorkflowPhase.IMPLEMENTATION:
+                if (!approvals.tasks.approved) {
+                    violations.push('Implementation phase active but tasks not approved');
+                }
+                break;
+        }
+        // Generate recommendations
+        if (approvals.requirements.generated && !approvals.requirements.approved) {
+            recommendations.push('Requirements are ready for review and approval');
+        }
+        if (approvals.design.generated && !approvals.design.approved) {
+            recommendations.push('Design is ready for review and approval');
+        }
+        if (approvals.tasks.generated && !approvals.tasks.approved) {
+            recommendations.push('Tasks are ready for review and approval');
+        }
+        return {
+            isValid: violations.length === 0,
+            violations,
+            recommendations
+        };
+    }
+}
+//# sourceMappingURL=WorkflowStateMachine.js.map