sdd-mcp-server 1.0.0

package/dist/application/services/ProjectService.js

@@ -0,0 +1,159 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { injectable, inject } from 'inversify';
+import { v4 as uuidv4 } from 'uuid';
+import { TYPES } from '../../infrastructure/di/types.js';
+import { WorkflowPhase } from '../../domain/types.js';
+import { projectSchema } from '../../infrastructure/schemas/project.schema.js';
+let ProjectService = class ProjectService {
+    projectRepository;
+    fileSystem;
+    validation;
+    logger;
+    constructor(projectRepository, fileSystem, validation, logger) {
+        this.projectRepository = projectRepository;
+        this.fileSystem = fileSystem;
+        this.validation = validation;
+        this.logger = logger;
+    }
+    async createProject(name, path, language = 'en') {
+        const correlationId = uuidv4();
+        this.logger.info('Creating new project', {
+            correlationId,
+            name,
+            path,
+            language
+        });
+        const project = {
+            id: uuidv4(),
+            name,
+            path,
+            phase: WorkflowPhase.INIT,
+            metadata: {
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                language,
+                approvals: {
+                    requirements: { generated: false, approved: false },
+                    design: { generated: false, approved: false },
+                    tasks: { generated: false, approved: false }
+                }
+            }
+        };
+        // Validate project data
+        await this.validation.validate(project, projectSchema);
+        // Create project directory structure
+        await this.createProjectStructure(project.path);
+        // Save project
+        await this.projectRepository.save(project);
+        this.logger.info('Project created successfully', {
+            correlationId,
+            projectId: project.id
+        });
+        return project;
+    }
+    async getProject(id) {
+        return await this.projectRepository.findById(id);
+    }
+    async getProjectByPath(path) {
+        return await this.projectRepository.findByPath(path);
+    }
+    async listProjects() {
+        return await this.projectRepository.list();
+    }
+    async updateProjectPhase(projectId, phase) {
+        const correlationId = uuidv4();
+        this.logger.info('Updating project phase', {
+            correlationId,
+            projectId,
+            phase
+        });
+        const project = await this.projectRepository.findById(projectId);
+        if (!project) {
+            throw new Error(`Project not found: ${projectId}`);
+        }
+        const updatedProject = {
+            ...project,
+            phase,
+            metadata: {
+                ...project.metadata,
+                updatedAt: new Date()
+            }
+        };
+        await this.validation.validate(updatedProject, projectSchema);
+        await this.projectRepository.save(updatedProject);
+        this.logger.info('Project phase updated successfully', {
+            correlationId,
+            projectId,
+            phase
+        });
+        return updatedProject;
+    }
+    async updateApprovalStatus(projectId, phaseType, status) {
+        const correlationId = uuidv4();
+        this.logger.info('Updating approval status', {
+            correlationId,
+            projectId,
+            phaseType,
+            status
+        });
+        const project = await this.projectRepository.findById(projectId);
+        if (!project) {
+            throw new Error(`Project not found: ${projectId}`);
+        }
+        const updatedProject = {
+            ...project,
+            metadata: {
+                ...project.metadata,
+                updatedAt: new Date(),
+                approvals: {
+                    ...project.metadata.approvals,
+                    [phaseType]: {
+                        ...project.metadata.approvals[phaseType],
+                        ...status
+                    }
+                }
+            }
+        };
+        await this.validation.validate(updatedProject, projectSchema);
+        await this.projectRepository.save(updatedProject);
+        this.logger.info('Approval status updated successfully', {
+            correlationId,
+            projectId,
+            phaseType
+        });
+        return updatedProject;
+    }
+    async createProjectStructure(basePath) {
+        const directories = [
+            `${basePath}/.kiro/specs`,
+            `${basePath}/.kiro/steering`,
+            `${basePath}/.claude/commands`
+        ];
+        for (const dir of directories) {
+            if (!(await this.fileSystem.exists(dir))) {
+                await this.fileSystem.mkdir(dir);
+            }
+        }
+    }
+};
+ProjectService = __decorate([
+    injectable(),
+    __param(0, inject(TYPES.ProjectRepository)),
+    __param(1, inject(TYPES.FileSystemPort)),
+    __param(2, inject(TYPES.ValidationPort)),
+    __param(3, inject(TYPES.LoggerPort)),
+    __metadata("design:paramtypes", [Object, Object, Object, Object])
+], ProjectService);
+export { ProjectService };
+//# sourceMappingURL=ProjectService.js.map

package/dist/application/services/ProjectService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProjectService.js","sourceRoot":"","sources":["../../../src/application/services/ProjectService.ts"],"names":[],"mappings":"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"}

package/dist/application/services/QualityGateService.d.ts

@@ -0,0 +1,62 @@
+import type { LoggerPort, FileSystemPort } from '../../domain/ports.js';
+import { WorkflowPhase } from '../../domain/types.js';
+import type { Project } from '../../domain/types.js';
+import type { CodeQualityAnalyzerPort, QualityReport } from '../../domain/quality/index.js';
+import { QualityScore, ViolationSeverity, ImprovementPriority } from '../../domain/quality/index.js';
+export interface QualityGateConfig {
+    readonly enforceOnPhases: WorkflowPhase[];
+    readonly minimumScore: QualityScore;
+    readonly maxCriticalViolations: number;
+    readonly maxMajorViolations: number;
+    readonly requiredImprovements: ImprovementPriority[];
+    readonly excludePatterns: string[];
+    readonly includePatterns: string[];
+    readonly failOnGarbage: boolean;
+    readonly generateReports: boolean;
+}
+export interface QualityGateResult {
+    readonly passed: boolean;
+    readonly phase: WorkflowPhase;
+    readonly project: Project;
+    readonly report: QualityReport;
+    readonly blockers: QualityBlocker[];
+    readonly warnings: QualityWarning[];
+    readonly recommendations: string[];
+    readonly executedAt: Date;
+}
+export interface QualityBlocker {
+    readonly type: 'score' | 'violations' | 'debt';
+    readonly severity: ViolationSeverity;
+    readonly description: string;
+    readonly files: string[];
+    readonly suggestedAction: string;
+    readonly estimatedEffort: string;
+}
+export interface QualityWarning {
+    readonly type: 'trend' | 'pattern' | 'maintenance';
+    readonly description: string;
+    readonly impact: string;
+    readonly suggestion: string;
+}
+export declare class QualityGateService {
+    private readonly logger;
+    private readonly fileSystem;
+    private readonly qualityAnalyzer;
+    private readonly config;
+    constructor(logger: LoggerPort, fileSystem: FileSystemPort, qualityAnalyzer: CodeQualityAnalyzerPort, config?: Partial<QualityGateConfig>);
+    executeQualityGate(project: Project, phase: WorkflowPhase, customConfig?: Partial<QualityGateConfig>): Promise<QualityGateResult>;
+    validateRequirementsQuality(project: Project): Promise<QualityGateResult>;
+    validateDesignQuality(project: Project): Promise<QualityGateResult>;
+    validateTasksQuality(project: Project): Promise<QualityGateResult>;
+    validateImplementationQuality(project: Project): Promise<QualityGateResult>;
+    private discoverSourceFiles;
+    private findFilesRecursively;
+    private analyzeSourceFiles;
+    private evaluateQualityCriteria;
+    private generateWarnings;
+    private generateRecommendations;
+    private generateQualityReport;
+    private createPassingResult;
+    getQualityConfig(): Promise<QualityGateConfig>;
+    updateQualityConfig(updates: Partial<QualityGateConfig>): Promise<void>;
+}

package/dist/application/services/QualityGateService.js

@@ -0,0 +1,428 @@
+// Quality gate service for integrating code quality enforcement throughout the SDD workflow
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { injectable, inject } from 'inversify';
+import { WorkflowPhase } from '../../domain/types.js';
+import { QualityScore, ViolationSeverity, ImprovementPriority } from '../../domain/quality/index.js';
+import { TYPES } from '../../infrastructure/di/types.js';
+const DEFAULT_QUALITY_CONFIG = {
+    enforceOnPhases: [WorkflowPhase.REQUIREMENTS, WorkflowPhase.DESIGN, WorkflowPhase.TASKS, WorkflowPhase.IMPLEMENTATION],
+    minimumScore: QualityScore.PASSABLE,
+    maxCriticalViolations: 0,
+    maxMajorViolations: 5,
+    requiredImprovements: [ImprovementPriority.HIGH],
+    excludePatterns: ['*.test.ts', '*.spec.ts', 'node_modules/**', 'dist/**'],
+    includePatterns: ['src/**/*.ts', 'src/**/*.js'],
+    failOnGarbage: true,
+    generateReports: true
+};
+let QualityGateService = class QualityGateService {
+    logger;
+    fileSystem;
+    qualityAnalyzer;
+    config;
+    constructor(logger, fileSystem, qualityAnalyzer, config = {}) {
+        this.logger = logger;
+        this.fileSystem = fileSystem;
+        this.qualityAnalyzer = qualityAnalyzer;
+        this.config = { ...DEFAULT_QUALITY_CONFIG, ...config };
+    }
+    async executeQualityGate(project, phase, customConfig) {
+        const effectiveConfig = customConfig
+            ? { ...this.config, ...customConfig }
+            : this.config;
+        this.logger.info('Executing quality gate', {
+            projectId: project.id,
+            phase,
+            minimumScore: effectiveConfig.minimumScore
+        });
+        try {
+            // Check if quality gate should run for this phase
+            if (!effectiveConfig.enforceOnPhases.includes(phase)) {
+                this.logger.debug('Quality gate skipped for phase', { phase });
+                return this.createPassingResult(project, phase);
+            }
+            // Discover and analyze source files
+            const sourceFiles = await this.discoverSourceFiles(project, effectiveConfig);
+            if (sourceFiles.length === 0) {
+                this.logger.warn('No source files found for quality analysis', {
+                    projectPath: project.path,
+                    patterns: effectiveConfig.includePatterns
+                });
+                return this.createPassingResult(project, phase);
+            }
+            // Perform quality analysis
+            const analysisResults = await this.analyzeSourceFiles(sourceFiles);
+            const qualityReport = await this.qualityAnalyzer.getQualityReport(analysisResults);
+            // Evaluate quality gate criteria
+            const blockers = this.evaluateQualityCriteria(qualityReport, effectiveConfig);
+            const warnings = this.generateWarnings(qualityReport);
+            const recommendations = this.generateRecommendations(qualityReport, phase);
+            const passed = blockers.length === 0;
+            // Generate quality report if enabled
+            if (effectiveConfig.generateReports) {
+                await this.generateQualityReport(project, phase, qualityReport);
+            }
+            const result = {
+                passed,
+                phase,
+                project,
+                report: qualityReport,
+                blockers,
+                warnings,
+                recommendations,
+                executedAt: new Date()
+            };
+            this.logger.info('Quality gate completed', {
+                projectId: project.id,
+                phase,
+                passed,
+                blockersCount: blockers.length,
+                warningsCount: warnings.length
+            });
+            return result;
+        }
+        catch (error) {
+            this.logger.error('Quality gate execution failed', {
+                projectId: project.id,
+                phase,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+        }
+    }
+    async validateRequirementsQuality(project) {
+        // Requirements phase: Focus on clarity, completeness, and testability
+        const config = {
+            minimumScore: QualityScore.PASSABLE,
+            maxCriticalViolations: 0,
+            maxMajorViolations: 3,
+            includePatterns: ['**/requirements.md', '**/specs/**/*.md']
+        };
+        return this.executeQualityGate(project, WorkflowPhase.REQUIREMENTS, config);
+    }
+    async validateDesignQuality(project) {
+        // Design phase: Focus on architecture, modularity, and maintainability
+        const config = {
+            minimumScore: QualityScore.PASSABLE,
+            maxCriticalViolations: 0,
+            maxMajorViolations: 5,
+            requiredImprovements: [ImprovementPriority.HIGH],
+            includePatterns: ['**/design.md', 'src/**/*.ts', '!src/**/*.test.ts']
+        };
+        return this.executeQualityGate(project, WorkflowPhase.DESIGN, config);
+    }
+    async validateTasksQuality(project) {
+        // Tasks phase: Focus on implementation plan quality and feasibility
+        const config = {
+            minimumScore: QualityScore.PASSABLE,
+            maxCriticalViolations: 0,
+            maxMajorViolations: 2,
+            includePatterns: ['**/tasks.md', 'src/**/*.ts']
+        };
+        return this.executeQualityGate(project, WorkflowPhase.TASKS, config);
+    }
+    async validateImplementationQuality(project) {
+        // Implementation phase: Full code quality analysis
+        const config = {
+            minimumScore: QualityScore.PASSABLE,
+            maxCriticalViolations: 0,
+            maxMajorViolations: 10,
+            requiredImprovements: [ImprovementPriority.HIGH, ImprovementPriority.MEDIUM],
+            failOnGarbage: true
+        };
+        return this.executeQualityGate(project, WorkflowPhase.IMPLEMENTATION, config);
+    }
+    async discoverSourceFiles(project, config) {
+        const files = [];
+        try {
+            // This is a simplified implementation - in production, would use glob patterns
+            const srcDir = `${project.path}/src`;
+            if (await this.fileSystem.exists(srcDir)) {
+                const sourceFiles = await this.findFilesRecursively(srcDir, config.includePatterns, config.excludePatterns);
+                for (const filePath of sourceFiles) {
+                    try {
+                        const content = await this.fileSystem.readFile(filePath);
+                        files.push({ path: filePath, content });
+                    }
+                    catch (error) {
+                        this.logger.warn('Failed to read source file', {
+                            filePath,
+                            error: error instanceof Error ? error.message : String(error)
+                        });
+                    }
+                }
+            }
+            // Also check documentation files for requirements/design phases
+            const docsFiles = [
+                `${project.path}/.kiro/specs/${project.name}/requirements.md`,
+                `${project.path}/.kiro/specs/${project.name}/design.md`,
+                `${project.path}/.kiro/specs/${project.name}/tasks.md`
+            ];
+            for (const filePath of docsFiles) {
+                if (await this.fileSystem.exists(filePath)) {
+                    try {
+                        const content = await this.fileSystem.readFile(filePath);
+                        files.push({ path: filePath, content });
+                    }
+                    catch (error) {
+                        this.logger.debug('Failed to read documentation file', {
+                            filePath,
+                            error: error instanceof Error ? error.message : String(error)
+                        });
+                    }
+                }
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to discover source files', {
+                projectPath: project.path,
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+        return files;
+    }
+    async findFilesRecursively(dir, includePatterns, excludePatterns) {
+        // Simplified file discovery - in production would use proper glob matching
+        const files = [];
+        try {
+            if (await this.fileSystem.exists(dir)) {
+                // This is a placeholder - would implement proper recursive file discovery
+                const typescriptFiles = [
+                    `${dir}/index.ts`,
+                    `${dir}/main.ts`,
+                    `${dir}/app.ts`
+                ];
+                for (const file of typescriptFiles) {
+                    if (await this.fileSystem.exists(file)) {
+                        files.push(file);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            this.logger.error('File discovery failed', {
+                dir,
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+        return files;
+    }
+    async analyzeSourceFiles(sourceFiles) {
+        const results = [];
+        for (const file of sourceFiles) {
+            try {
+                const analysis = await this.qualityAnalyzer.analyzeFile(file.path, file.content);
+                results.push(analysis);
+            }
+            catch (error) {
+                this.logger.warn('Failed to analyze source file', {
+                    filePath: file.path,
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+        }
+        return results;
+    }
+    evaluateQualityCriteria(report, config) {
+        const blockers = [];
+        // Check overall quality score
+        if (config.failOnGarbage && report.overall === QualityScore.GARBAGE) {
+            blockers.push({
+                type: 'score',
+                severity: ViolationSeverity.CRITICAL,
+                description: 'Overall code quality is rated as GARBAGE',
+                files: report.files.filter(f => f.overallScore === QualityScore.GARBAGE).map(f => f.filePath),
+                suggestedAction: 'Refactor code to improve taste, reduce complexity, and eliminate special cases',
+                estimatedEffort: '16-40 hours'
+            });
+        }
+        // Check minimum score requirement
+        const scoreValues = {
+            [QualityScore.GOOD]: 3,
+            [QualityScore.PASSABLE]: 2,
+            [QualityScore.GARBAGE]: 1
+        };
+        if (scoreValues[report.overall] < scoreValues[config.minimumScore]) {
+            blockers.push({
+                type: 'score',
+                severity: ViolationSeverity.MAJOR,
+                description: `Code quality (${report.overall}) is below minimum requirement (${config.minimumScore})`,
+                files: report.files.map(f => f.filePath),
+                suggestedAction: 'Address quality issues to meet minimum standards',
+                estimatedEffort: '4-16 hours'
+            });
+        }
+        // Check violation thresholds
+        const criticalViolations = report.files.reduce((sum, file) => sum + file.violations.filter(v => v.severity === ViolationSeverity.CRITICAL).length, 0);
+        if (criticalViolations > config.maxCriticalViolations) {
+            blockers.push({
+                type: 'violations',
+                severity: ViolationSeverity.CRITICAL,
+                description: `${criticalViolations} critical violations exceed limit of ${config.maxCriticalViolations}`,
+                files: report.files.filter(f => f.violations.some(v => v.severity === ViolationSeverity.CRITICAL)).map(f => f.filePath),
+                suggestedAction: 'Fix all critical violations before proceeding',
+                estimatedEffort: '1-4 hours per violation'
+            });
+        }
+        const majorViolations = report.files.reduce((sum, file) => sum + file.violations.filter(v => v.severity === ViolationSeverity.MAJOR).length, 0);
+        if (majorViolations > config.maxMajorViolations) {
+            blockers.push({
+                type: 'violations',
+                severity: ViolationSeverity.MAJOR,
+                description: `${majorViolations} major violations exceed limit of ${config.maxMajorViolations}`,
+                files: report.files.filter(f => f.violations.some(v => v.severity === ViolationSeverity.MAJOR)).map(f => f.filePath),
+                suggestedAction: 'Address major violations to improve code quality',
+                estimatedEffort: '30min-2 hours per violation'
+            });
+        }
+        // Check technical debt
+        if (report.summary.technicalDebt > 40) {
+            blockers.push({
+                type: 'debt',
+                severity: ViolationSeverity.MAJOR,
+                description: `Technical debt of ${report.summary.technicalDebt} hours is too high`,
+                files: report.files.map(f => f.filePath),
+                suggestedAction: 'Prioritize technical debt reduction',
+                estimatedEffort: `${Math.ceil(report.summary.technicalDebt / 4)} days`
+            });
+        }
+        return blockers;
+    }
+    generateWarnings(report) {
+        const warnings = [];
+        // Check quality trends
+        const decliningTrends = report.trends.filter(t => t.direction === 'degrading');
+        if (decliningTrends.length > 0) {
+            warnings.push({
+                type: 'trend',
+                description: `${decliningTrends.length} quality metrics are declining`,
+                impact: 'Code quality may continue to degrade over time',
+                suggestion: 'Monitor and address declining trends proactively'
+            });
+        }
+        // Check for patterns
+        if (report.summary.passableFiles > report.summary.goodFiles) {
+            warnings.push({
+                type: 'pattern',
+                description: 'More files are rated as passable than good',
+                impact: 'Overall codebase quality is mediocre',
+                suggestion: 'Focus on improving passable files to good quality'
+            });
+        }
+        // Maintenance warnings
+        const avgComplexity = report.files.reduce((sum, f) => sum + f.complexityAnalysis.cyclomaticComplexity, 0) / report.files.length;
+        if (avgComplexity > 15) {
+            warnings.push({
+                type: 'maintenance',
+                description: 'Average complexity is high across the codebase',
+                impact: 'Code will be harder to maintain and debug',
+                suggestion: 'Refactor complex functions and reduce branching logic'
+            });
+        }
+        return warnings;
+    }
+    generateRecommendations(report, phase) {
+        const recommendations = [];
+        switch (phase) {
+            case WorkflowPhase.REQUIREMENTS:
+                recommendations.push('Ensure requirements are testable and measurable');
+                recommendations.push('Review requirements with stakeholders for completeness');
+                break;
+            case WorkflowPhase.DESIGN:
+                recommendations.push('Validate architectural decisions against requirements');
+                recommendations.push('Consider design patterns for complex interactions');
+                if (report.summary.technicalDebt > 20) {
+                    recommendations.push('Design should minimize technical debt accumulation');
+                }
+                break;
+            case WorkflowPhase.TASKS:
+                recommendations.push('Break down complex tasks into smaller, manageable units');
+                recommendations.push('Ensure task dependencies are clearly defined');
+                break;
+            case WorkflowPhase.IMPLEMENTATION:
+                recommendations.push('Focus on high-priority quality improvements first');
+                if (report.summary.garbageFiles > 0) {
+                    recommendations.push('Refactor garbage-quality files before proceeding');
+                }
+                recommendations.push('Add comprehensive tests for complex logic');
+                break;
+        }
+        // Add general recommendations based on report
+        if (report.summary.technicalDebt > 10) {
+            recommendations.push(`Address ${Math.ceil(report.summary.technicalDebt)} hours of technical debt`);
+        }
+        return recommendations;
+    }
+    async generateQualityReport(project, phase, report) {
+        try {
+            const reportDir = `${project.path}/.kiro/quality`;
+            await this.fileSystem.mkdir(reportDir);
+            const reportPath = `${reportDir}/quality-report-${phase.toLowerCase()}-${Date.now()}.json`;
+            const reportContent = JSON.stringify(report, null, 2);
+            await this.fileSystem.writeFile(reportPath, reportContent);
+            this.logger.debug('Quality report generated', { reportPath });
+        }
+        catch (error) {
+            this.logger.warn('Failed to generate quality report', {
+                projectId: project.id,
+                phase,
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    createPassingResult(project, phase) {
+        return {
+            passed: true,
+            phase,
+            project,
+            report: {
+                overall: QualityScore.GOOD,
+                summary: {
+                    totalFiles: 0,
+                    goodFiles: 0,
+                    passableFiles: 0,
+                    garbageFiles: 0,
+                    averageScore: 10,
+                    topIssues: [],
+                    technicalDebt: 0
+                },
+                files: [],
+                trends: [],
+                recommendations: [],
+                generatedAt: new Date()
+            },
+            blockers: [],
+            warnings: [],
+            recommendations: [],
+            executedAt: new Date()
+        };
+    }
+    // Public utility methods
+    async getQualityConfig() {
+        return this.config;
+    }
+    async updateQualityConfig(updates) {
+        Object.assign(this.config, updates);
+        this.logger.info('Quality gate configuration updated', updates);
+    }
+};
+QualityGateService = __decorate([
+    injectable(),
+    __param(0, inject(TYPES.LoggerPort)),
+    __param(1, inject(TYPES.FileSystemPort)),
+    __param(2, inject(TYPES.CodeQualityAnalyzerPort)),
+    __metadata("design:paramtypes", [Object, Object, Object, Object])
+], QualityGateService);
+export { QualityGateService };
+//# sourceMappingURL=QualityGateService.js.map