adpa-enterprise-framework-automation
Version:
Modular, standards-compliant Node.js/TypeScript automation framework for enterprise requirements, project, and data management. Provides CLI and API for BABOK v3, PMBOK 7th Edition, and DMBOK 2.0 (in progress). Production-ready Express.js API with TypeSpe
299 lines • 12.3 kB
JavaScript
import { StandardsComplianceAnalysisEngine } from '../modules/standardsCompliance/StandardsComplianceEngine.js';
import { PMBOKValidator } from '../modules/pmbokValidation/PMBOKValidator.js';
/**
* Enhanced Risk and Compliance Assessment Service
*
* This service provides comprehensive risk and compliance assessment capabilities
* by integrating risk management with multi-standard compliance evaluation.
*/
export class RiskComplianceAssessmentService {
complianceEngine;
pmbokValidator;
constructor() {
const config = {
enabledStandards: ['PMBOK_7', 'BABOK_V3', 'DMBOK_2', 'ISO_15408'],
analysisDepth: 'COMPREHENSIVE',
intelligentDeviationThreshold: 75,
riskToleranceLevel: 'MEDIUM',
includeRecommendations: true,
generateExecutiveSummary: true,
outputFormat: 'JSON'
};
this.complianceEngine = new StandardsComplianceAnalysisEngine(config);
this.pmbokValidator = new PMBOKValidator();
}
/**
* Performs comprehensive risk and compliance assessment
*/
async performIntegratedAssessment(projectData) {
try {
// Perform compliance analysis
const complianceResults = await this.performComplianceAnalysis(projectData);
// Perform risk assessment
const riskAssessment = await this.performRiskAssessment(projectData, complianceResults);
// Generate integrated analysis
const integratedAnalysis = await this.generateIntegratedAnalysis(projectData, complianceResults, riskAssessment);
// Generate executive summary
const executiveSummary = await this.generateExecutiveSummary(integratedAnalysis);
return {
projectId: projectData.projectId,
assessmentDate: new Date(),
complianceResults,
riskAssessment,
integratedAnalysis,
executiveSummary,
recommendations: await this.generateRecommendations(integratedAnalysis),
overallRiskLevel: this.calculateOverallRiskLevel(riskAssessment, complianceResults),
complianceScore: this.calculateOverallComplianceScore(complianceResults)
};
}
catch (error) {
console.error('Error performing integrated assessment:', error);
if (error instanceof Error) {
throw new Error(`Failed to perform integrated risk and compliance assessment: ${error.message}`);
}
else {
throw new Error('Failed to perform integrated risk and compliance assessment: Unknown error');
}
}
}
/**
* Performs multi-standard compliance analysis
*/
async performComplianceAnalysis(projectData) {
const results = [];
try {
// PMBOK 7.0 Analysis
const pmbokResult = await this.complianceEngine.validateAgainstPMBOK(projectData);
results.push(pmbokResult);
// BABOK v3 Analysis (if applicable)
if (this.isBABOKApplicable(projectData)) {
const babokResult = await this.complianceEngine.validateAgainstBABOK(projectData);
results.push(babokResult);
}
// DMBOK 2.0 Analysis (if applicable)
if (this.isDMBOKApplicable(projectData)) {
const dmbokResult = await this.complianceEngine.validateAgainstDMBOK(projectData);
results.push(dmbokResult);
}
// ISO 15408 Analysis (if applicable)
if (this.isISO15408Applicable(projectData)) {
const isoResult = await this.complianceEngine.validateAgainstISO15408(projectData);
results.push(isoResult);
}
return results;
}
catch (error) {
console.error('Error in compliance analysis:', error);
throw error;
}
}
/**
* Performs comprehensive risk assessment
*/
async performRiskAssessment(projectData, complianceResults) {
const risks = [];
// Identify risks from project characteristics
risks.push(...await this.identifyProjectRisks(projectData));
// Identify risks from compliance gaps
risks.push(...await this.identifyComplianceRisks(complianceResults));
// Assess and prioritize risks
const assessedRisks = await this.assessRisks(risks, projectData);
// Generate risk response strategies
const responseStrategies = await this.generateRiskResponseStrategies(assessedRisks);
return {
risks: assessedRisks,
riskMatrix: this.generateRiskMatrix(assessedRisks),
responseStrategies,
overallRiskLevel: this.calculateProjectRiskLevel(assessedRisks),
keyRiskIndicators: this.identifyKeyRiskIndicators(assessedRisks)
};
}
/**
* Generates integrated analysis combining risk and compliance
*/
async generateIntegratedAnalysis(projectData, complianceResults, riskAssessment) {
const analysisRequest = {
requestId: `integrated-${projectData.projectId}-${Date.now()}`,
projectData,
enabledStandards: ['PMBOK_7', 'BABOK_V3', 'DMBOK_2', 'ISO_15408'],
analysisOptions: {
includeIntelligentDeviations: true,
includeCrossStandardAnalysis: true,
generateExecutiveSummary: true,
detailLevel: 'COMPREHENSIVE',
riskAssessmentLevel: 'COMPREHENSIVE'
},
requestDate: new Date(),
requestor: 'RiskComplianceAssessmentService'
};
return await this.complianceEngine.generateDeviationAnalysis(complianceResults);
}
/**
* Identifies risks specific to project characteristics
*/
async identifyProjectRisks(projectData) {
const risks = [];
// Strategic risks
if (projectData.complexity === 'VERY_HIGH') {
risks.push({
id: 'STR-001',
category: 'STRATEGIC',
description: 'High project complexity may lead to scope creep and stakeholder misalignment',
probability: 'HIGH',
impact: 'MAJOR',
riskLevel: 'HIGH'
});
}
// Operational risks
if (projectData.teamSize > 50) {
risks.push({
id: 'OPR-001',
category: 'OPERATIONAL',
description: 'Large team size increases communication and coordination risks',
probability: 'MEDIUM',
impact: 'MODERATE',
riskLevel: 'MEDIUM'
});
}
// Financial risks
if (projectData.budget > 1000000) {
risks.push({
id: 'FIN-001',
category: 'FINANCIAL',
description: 'High budget project increases financial oversight and cost control risks',
probability: 'MEDIUM',
impact: 'MAJOR',
riskLevel: 'HIGH'
});
}
// Regulatory risks
if (projectData.regulatoryRequirements.length > 0) {
risks.push({
id: 'REG-001',
category: 'REGULATORY',
description: 'Multiple regulatory requirements increase compliance and audit risks',
probability: 'MEDIUM',
impact: 'MAJOR',
riskLevel: 'HIGH'
});
}
return risks;
}
/**
* Identifies risks from compliance gaps
*/
async identifyComplianceRisks(complianceResults) {
const risks = [];
for (const result of complianceResults) {
if (result.overallScore < 70) {
risks.push({
id: `COMP-${result.standard}`,
category: 'COMPLIANCE',
description: `Low compliance score (${result.overallScore}%) for ${result.standard} creates regulatory and operational risks`,
probability: 'HIGH',
impact: 'MAJOR',
riskLevel: 'HIGH'
});
}
// Add risks for critical issues
result.criticalIssues.forEach((issue, index) => {
risks.push({
id: `COMP-${result.standard}-${index + 1}`,
category: 'COMPLIANCE',
description: `Critical compliance issue: ${issue.description}`,
probability: 'HIGH',
impact: issue.impact,
riskLevel: this.mapImpactToRiskLevel(issue.impact)
});
});
}
return risks;
}
/**
* Utility methods
*/
isBABOKApplicable(projectData) {
return projectData.projectType === 'BUSINESS_TRANSFORMATION' ||
projectData.documents.some(doc => doc.type === 'REQUIREMENTS');
}
isDMBOKApplicable(projectData) {
return projectData.projectType === 'DATA_MIGRATION' ||
projectData.documents.some(doc => doc.name.toLowerCase().includes('data'));
}
isISO15408Applicable(projectData) {
return projectData.regulatoryRequirements.some(req => req.name.toLowerCase().includes('security') ||
req.name.toLowerCase().includes('iso'));
}
calculateOverallRiskLevel(riskAssessment, complianceResults) {
const riskScore = riskAssessment.overallRiskLevel;
const avgComplianceScore = complianceResults.reduce((sum, result) => sum + result.overallScore, 0) / complianceResults.length;
if (riskScore === 'VERY_HIGH' || avgComplianceScore < 50)
return 'VERY_HIGH';
if (riskScore === 'HIGH' || avgComplianceScore < 70)
return 'HIGH';
if (riskScore === 'MEDIUM' || avgComplianceScore < 85)
return 'MEDIUM';
if (riskScore === 'LOW' || avgComplianceScore < 95)
return 'LOW';
return 'VERY_LOW';
}
calculateOverallComplianceScore(complianceResults) {
if (complianceResults.length === 0)
return 0;
return complianceResults.reduce((sum, result) => sum + result.overallScore, 0) / complianceResults.length;
}
mapImpactToRiskLevel(impact) {
switch (impact) {
case 'SEVERE': return 'VERY_HIGH';
case 'MAJOR': return 'HIGH';
case 'MODERATE': return 'MEDIUM';
case 'MINOR': return 'LOW';
default: return 'VERY_LOW';
}
}
async assessRisks(risks, projectData) {
// Enhanced risk assessment logic would go here
return risks;
}
generateRiskMatrix(risks) {
// Risk matrix generation logic
return {
highRisks: risks.filter(r => r.riskLevel === 'VERY_HIGH' || r.riskLevel === 'HIGH'),
mediumRisks: risks.filter(r => r.riskLevel === 'MEDIUM'),
lowRisks: risks.filter(r => r.riskLevel === 'LOW' || r.riskLevel === 'VERY_LOW')
};
}
async generateRiskResponseStrategies(risks) {
// Risk response strategy generation logic
return [];
}
calculateProjectRiskLevel(risks) {
const highRiskCount = risks.filter(r => r.riskLevel === 'VERY_HIGH' || r.riskLevel === 'HIGH').length;
const totalRisks = risks.length;
if (totalRisks === 0)
return 'VERY_LOW';
const highRiskRatio = highRiskCount / totalRisks;
if (highRiskRatio > 0.5)
return 'VERY_HIGH';
if (highRiskRatio > 0.3)
return 'HIGH';
if (highRiskRatio > 0.1)
return 'MEDIUM';
if (highRiskRatio > 0)
return 'LOW';
return 'VERY_LOW';
}
identifyKeyRiskIndicators(risks) {
// KRI identification logic
return [];
}
async generateRecommendations(analysis) {
// Recommendation generation logic
return [];
}
async generateExecutiveSummary(analysis) {
return await this.complianceEngine.generateExecutiveSummary(analysis);
}
}
//# sourceMappingURL=RiskComplianceAssessmentService.js.map