@erosolaraijs/cure 1.0.0

package/src/safety/drugInteractions.ts

@@ -0,0 +1,942 @@
+/**
+ * Drug Interaction and Safety Checking System
+ *
+ * Provides comprehensive drug safety checks:
+ * - Drug-drug interactions
+ * - Contraindication checking
+ * - Dosing validation
+ * - Allergy cross-reactivity
+ * - Organ function-based adjustments
+ * - Pregnancy/lactation safety
+ * - QT prolongation risk assessment
+ * - CYP450 interaction analysis
+ *
+ * Data sources would include:
+ * - FDA drug labels
+ * - DrugBank
+ * - PharmGKB
+ * - Clinical Pharmacology databases
+ */
+
+import { EventEmitter } from 'events';
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// DRUG INTERACTION TYPES
+// ═══════════════════════════════════════════════════════════════════════════════
+
+export interface Drug {
+  name: string;
+  genericName: string;
+  brandNames?: string[];
+  drugClass: string;
+  rxNormId?: string;
+  ndc?: string;
+  atcCode?: string;
+  mechanism?: string;
+  metabolism?: {
+    cyp450?: CYP450Profile;
+    renalExcretion?: number; // percentage
+    hepaticMetabolism?: number;
+  };
+}
+
+export interface CYP450Profile {
+  substrates?: string[]; // CYP enzymes this drug is metabolized by
+  inhibitors?: string[]; // CYP enzymes this drug inhibits
+  inducers?: string[]; // CYP enzymes this drug induces
+}
+
+export interface DrugInteraction {
+  drug1: string;
+  drug2: string;
+  severity: 'contraindicated' | 'major' | 'moderate' | 'minor';
+  type: 'pharmacokinetic' | 'pharmacodynamic' | 'additive' | 'synergistic' | 'antagonistic';
+  mechanism: string;
+  clinicalEffect: string;
+  management: string;
+  documentation: 'established' | 'theoretical' | 'case-report';
+  references?: string[];
+}
+
+export interface Contraindication {
+  drug: string;
+  condition: string;
+  severity: 'absolute' | 'relative';
+  reason: string;
+  alternatives?: string[];
+}
+
+export interface DosingGuideline {
+  drug: string;
+  indication: string;
+  standardDose: string;
+  renalAdjustment?: {
+    gfrThreshold: number;
+    adjustment: string;
+  }[];
+  hepaticAdjustment?: {
+    childPughClass: 'A' | 'B' | 'C';
+    adjustment: string;
+  }[];
+  ageAdjustment?: {
+    ageThreshold: number;
+    adjustment: string;
+  }[];
+  weightBasedDosing?: {
+    formula: string;
+    maxDose?: string;
+  };
+}
+
+export interface AllergyCheck {
+  reportedAllergy: string;
+  drugToCheck: string;
+  crossReactivity: boolean;
+  riskLevel: 'high' | 'moderate' | 'low' | 'none';
+  relatedAllergens: string[];
+  recommendation: string;
+}
+
+export interface SafetyAlert {
+  id: string;
+  type: 'interaction' | 'contraindication' | 'allergy' | 'dosing' | 'organ-function' | 'pregnancy' | 'qt-prolongation' | 'black-box';
+  severity: 'critical' | 'high' | 'moderate' | 'low';
+  title: string;
+  description: string;
+  affectedDrugs: string[];
+  recommendation: string;
+  overridable: boolean;
+  requiresDocumentation: boolean;
+  references?: string[];
+}
+
+export interface PatientSafetyProfile {
+  patientId: string;
+  allergies: {
+    allergen: string;
+    reactionType: 'anaphylaxis' | 'rash' | 'angioedema' | 'gi' | 'other';
+    severity: 'severe' | 'moderate' | 'mild';
+  }[];
+  renalFunction: {
+    gfr: number;
+    creatinine: number;
+    dialysis: boolean;
+  };
+  hepaticFunction: {
+    childPughClass?: 'A' | 'B' | 'C';
+    bilirubin?: number;
+    albumin?: number;
+    inr?: number;
+    ascites?: 'none' | 'mild' | 'moderate-severe';
+    encephalopathy?: 'none' | 'grade-1-2' | 'grade-3-4';
+  };
+  cardiacStatus: {
+    qtcInterval?: number;
+    lvef?: number;
+    arrhythmiaHistory?: boolean;
+    pacemakerIcd?: boolean;
+  };
+  currentMedications: {
+    drug: string;
+    dose: string;
+    frequency: string;
+    startDate?: Date;
+  }[];
+  demographics: {
+    age: number;
+    weight: number;
+    gender: 'male' | 'female';
+    pregnant?: boolean;
+    breastfeeding?: boolean;
+  };
+  geneticFactors?: {
+    cyp2d6?: 'poor' | 'intermediate' | 'normal' | 'rapid' | 'ultra-rapid';
+    cyp2c19?: 'poor' | 'intermediate' | 'normal' | 'rapid' | 'ultra-rapid';
+    dpyd?: 'deficient' | 'intermediate' | 'normal';
+    ugt1a1?: '*28/*28' | '*28/*1' | '*1/*1';
+    tpmt?: 'poor' | 'intermediate' | 'normal';
+  };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// DRUG SAFETY SERVICE
+// ═══════════════════════════════════════════════════════════════════════════════
+
+export class DrugSafetyService extends EventEmitter {
+  private interactionDatabase: Map<string, DrugInteraction[]> = new Map();
+  private contraindicationDatabase: Map<string, Contraindication[]> = new Map();
+  private dosingGuidelines: Map<string, DosingGuideline[]> = new Map();
+  private allergenCrossReactivity: Map<string, string[]> = new Map();
+  private qtProlongingDrugs: Set<string> = new Set();
+  private blackBoxWarnings: Map<string, string[]> = new Map();
+
+  constructor() {
+    super();
+    this.initializeDatabases();
+  }
+
+  /**
+   * Perform comprehensive safety check
+   */
+  async performSafetyCheck(
+    patient: PatientSafetyProfile,
+    proposedDrugs: { drug: string; dose: string; route: string }[]
+  ): Promise<{
+    safe: boolean;
+    alerts: SafetyAlert[];
+    summary: {
+      criticalAlerts: number;
+      highAlerts: number;
+      moderateAlerts: number;
+      lowAlerts: number;
+      overallRisk: 'critical' | 'high' | 'moderate' | 'low' | 'minimal';
+    };
+    recommendations: string[];
+  }> {
+    const alerts: SafetyAlert[] = [];
+    const recommendations: string[] = [];
+
+    // Get all drugs (current + proposed)
+    const allDrugs = [
+      ...patient.currentMedications.map(m => m.drug),
+      ...proposedDrugs.map(d => d.drug)
+    ];
+
+    // 1. Check drug-drug interactions
+    const interactionAlerts = await this.checkDrugInteractions(allDrugs);
+    alerts.push(...interactionAlerts);
+
+    // 2. Check contraindications based on patient conditions
+    const contraindicationAlerts = await this.checkContraindications(proposedDrugs.map(d => d.drug), patient);
+    alerts.push(...contraindicationAlerts);
+
+    // 3. Check allergies and cross-reactivity
+    const allergyAlerts = await this.checkAllergies(proposedDrugs.map(d => d.drug), patient.allergies);
+    alerts.push(...allergyAlerts);
+
+    // 4. Check dosing based on organ function
+    const dosingAlerts = await this.checkDosing(proposedDrugs, patient);
+    alerts.push(...dosingAlerts);
+
+    // 5. Check QT prolongation risk
+    const qtAlerts = await this.checkQTProlongation(allDrugs, patient);
+    alerts.push(...qtAlerts);
+
+    // 6. Check pregnancy/lactation
+    if (patient.demographics.pregnant || patient.demographics.breastfeeding) {
+      const pregnancyAlerts = await this.checkPregnancySafety(proposedDrugs.map(d => d.drug), patient);
+      alerts.push(...pregnancyAlerts);
+    }
+
+    // 7. Check black box warnings
+    const blackBoxAlerts = await this.checkBlackBoxWarnings(proposedDrugs.map(d => d.drug));
+    alerts.push(...blackBoxAlerts);
+
+    // 8. Check pharmacogenomic considerations
+    if (patient.geneticFactors) {
+      const pgxAlerts = await this.checkPharmacogenomics(proposedDrugs.map(d => d.drug), patient.geneticFactors);
+      alerts.push(...pgxAlerts);
+    }
+
+    // Count alerts by severity
+    const criticalAlerts = alerts.filter(a => a.severity === 'critical').length;
+    const highAlerts = alerts.filter(a => a.severity === 'high').length;
+    const moderateAlerts = alerts.filter(a => a.severity === 'moderate').length;
+    const lowAlerts = alerts.filter(a => a.severity === 'low').length;
+
+    // Determine overall risk
+    let overallRisk: 'critical' | 'high' | 'moderate' | 'low' | 'minimal';
+    if (criticalAlerts > 0) overallRisk = 'critical';
+    else if (highAlerts > 0) overallRisk = 'high';
+    else if (moderateAlerts > 0) overallRisk = 'moderate';
+    else if (lowAlerts > 0) overallRisk = 'low';
+    else overallRisk = 'minimal';
+
+    // Generate recommendations
+    for (const alert of alerts.filter(a => a.severity === 'critical' || a.severity === 'high')) {
+      recommendations.push(alert.recommendation);
+    }
+
+    // Determine if safe to proceed
+    const safe = criticalAlerts === 0 && !alerts.some(a => !a.overridable);
+
+    // Emit event
+    this.emit('safety-check-completed', { patientId: patient.patientId, safe, alertCount: alerts.length });
+
+    return {
+      safe,
+      alerts: alerts.sort((a, b) => {
+        const severityOrder = { critical: 0, high: 1, moderate: 2, low: 3 };
+        return severityOrder[a.severity] - severityOrder[b.severity];
+      }),
+      summary: {
+        criticalAlerts,
+        highAlerts,
+        moderateAlerts,
+        lowAlerts,
+        overallRisk
+      },
+      recommendations
+    };
+  }
+
+  /**
+   * Check drug-drug interactions
+   */
+  async checkDrugInteractions(drugs: string[]): Promise<SafetyAlert[]> {
+    const alerts: SafetyAlert[] = [];
+    const checkedPairs = new Set<string>();
+
+    for (let i = 0; i < drugs.length; i++) {
+      for (let j = i + 1; j < drugs.length; j++) {
+        const drug1 = drugs[i].toLowerCase();
+        const drug2 = drugs[j].toLowerCase();
+        const pairKey = [drug1, drug2].sort().join('|');
+
+        if (checkedPairs.has(pairKey)) continue;
+        checkedPairs.add(pairKey);
+
+        const interaction = this.findInteraction(drug1, drug2);
+        if (interaction) {
+          alerts.push({
+            id: `DDI-${Date.now()}-${i}-${j}`,
+            type: 'interaction',
+            severity: this.mapInteractionSeverity(interaction.severity),
+            title: `Drug Interaction: ${drugs[i]} + ${drugs[j]}`,
+            description: interaction.clinicalEffect,
+            affectedDrugs: [drugs[i], drugs[j]],
+            recommendation: interaction.management,
+            overridable: interaction.severity !== 'contraindicated',
+            requiresDocumentation: interaction.severity === 'major' || interaction.severity === 'contraindicated',
+            references: interaction.references
+          });
+        }
+      }
+    }
+
+    return alerts;
+  }
+
+  /**
+   * Check contraindications
+   */
+  async checkContraindications(drugs: string[], patient: PatientSafetyProfile): Promise<SafetyAlert[]> {
+    const alerts: SafetyAlert[] = [];
+
+    // Check renal contraindications
+    if (patient.renalFunction.gfr < 30) {
+      const renalContraindicated = ['metformin', 'nsaids', 'lithium', 'gadolinium'];
+      for (const drug of drugs) {
+        if (renalContraindicated.some(c => drug.toLowerCase().includes(c))) {
+          alerts.push({
+            id: `CI-RENAL-${Date.now()}`,
+            type: 'contraindication',
+            severity: patient.renalFunction.gfr < 15 ? 'critical' : 'high',
+            title: `Renal Contraindication: ${drug}`,
+            description: `${drug} is contraindicated or requires significant dose adjustment with GFR ${patient.renalFunction.gfr} mL/min`,
+            affectedDrugs: [drug],
+            recommendation: `Consider alternative therapy or significant dose reduction. Consult nephrology if essential.`,
+            overridable: patient.renalFunction.gfr >= 15,
+            requiresDocumentation: true
+          });
+        }
+      }
+    }
+
+    // Check hepatic contraindications
+    if (patient.hepaticFunction.childPughClass === 'C') {
+      const hepaticContraindicated = ['methotrexate', 'valproic-acid', 'isoniazid', 'ketoconazole'];
+      for (const drug of drugs) {
+        if (hepaticContraindicated.some(c => drug.toLowerCase().includes(c))) {
+          alerts.push({
+            id: `CI-HEPATIC-${Date.now()}`,
+            type: 'contraindication',
+            severity: 'critical',
+            title: `Hepatic Contraindication: ${drug}`,
+            description: `${drug} is contraindicated in Child-Pugh Class C liver disease`,
+            affectedDrugs: [drug],
+            recommendation: `Avoid use. Consider alternative therapy.`,
+            overridable: false,
+            requiresDocumentation: true
+          });
+        }
+      }
+    }
+
+    // Check cardiac contraindications
+    if (patient.cardiacStatus.lvef && patient.cardiacStatus.lvef < 40) {
+      const cardiacCaution = ['anthracycline', 'trastuzumab', 'sunitinib', 'sorafenib'];
+      for (const drug of drugs) {
+        if (cardiacCaution.some(c => drug.toLowerCase().includes(c))) {
+          alerts.push({
+            id: `CI-CARDIAC-${Date.now()}`,
+            type: 'contraindication',
+            severity: 'high',
+            title: `Cardiac Caution: ${drug}`,
+            description: `${drug} has cardiotoxicity risk. Patient LVEF is ${patient.cardiacStatus.lvef}%`,
+            affectedDrugs: [drug],
+            recommendation: `Baseline and serial cardiac monitoring required. Consider cardiology consultation.`,
+            overridable: true,
+            requiresDocumentation: true
+          });
+        }
+      }
+    }
+
+    return alerts;
+  }
+
+  /**
+   * Check allergy cross-reactivity
+   */
+  async checkAllergies(drugs: string[], allergies: PatientSafetyProfile['allergies']): Promise<SafetyAlert[]> {
+    const alerts: SafetyAlert[] = [];
+
+    for (const allergy of allergies) {
+      for (const drug of drugs) {
+        const crossReactivity = this.checkCrossReactivity(allergy.allergen, drug);
+
+        if (crossReactivity.crossReactivity) {
+          const severity = allergy.severity === 'severe' && crossReactivity.riskLevel === 'high'
+            ? 'critical'
+            : allergy.severity === 'severe' || crossReactivity.riskLevel === 'high'
+              ? 'high'
+              : 'moderate';
+
+          alerts.push({
+            id: `ALLERGY-${Date.now()}`,
+            type: 'allergy',
+            severity,
+            title: `Allergy Alert: ${drug}`,
+            description: `Patient allergic to ${allergy.allergen}. ${drug} has ${crossReactivity.riskLevel} cross-reactivity risk.`,
+            affectedDrugs: [drug],
+            recommendation: crossReactivity.recommendation,
+            overridable: allergy.severity !== 'severe' || crossReactivity.riskLevel !== 'high',
+            requiresDocumentation: true
+          });
+        }
+      }
+    }
+
+    return alerts;
+  }
+
+  /**
+   * Check dosing based on organ function
+   */
+  async checkDosing(
+    drugs: { drug: string; dose: string; route: string }[],
+    patient: PatientSafetyProfile
+  ): Promise<SafetyAlert[]> {
+    const alerts: SafetyAlert[] = [];
+
+    for (const drugOrder of drugs) {
+      const guidelines = this.dosingGuidelines.get(drugOrder.drug.toLowerCase());
+      if (!guidelines) continue;
+
+      for (const guideline of guidelines) {
+        // Check renal adjustment
+        if (guideline.renalAdjustment) {
+          for (const adj of guideline.renalAdjustment) {
+            if (patient.renalFunction.gfr < adj.gfrThreshold) {
+              alerts.push({
+                id: `DOSE-RENAL-${Date.now()}`,
+                type: 'dosing',
+                severity: 'moderate',
+                title: `Dose Adjustment Required: ${drugOrder.drug}`,
+                description: `Patient GFR ${patient.renalFunction.gfr} requires dose adjustment`,
+                affectedDrugs: [drugOrder.drug],
+                recommendation: adj.adjustment,
+                overridable: true,
+                requiresDocumentation: true
+              });
+              break;
+            }
+          }
+        }
+
+        // Check hepatic adjustment
+        if (guideline.hepaticAdjustment && patient.hepaticFunction.childPughClass) {
+          const adj = guideline.hepaticAdjustment.find(a => a.childPughClass === patient.hepaticFunction.childPughClass);
+          if (adj) {
+            alerts.push({
+              id: `DOSE-HEPATIC-${Date.now()}`,
+              type: 'dosing',
+              severity: patient.hepaticFunction.childPughClass === 'C' ? 'high' : 'moderate',
+              title: `Hepatic Dose Adjustment: ${drugOrder.drug}`,
+              description: `Child-Pugh Class ${patient.hepaticFunction.childPughClass} requires dose adjustment`,
+              affectedDrugs: [drugOrder.drug],
+              recommendation: adj.adjustment,
+              overridable: patient.hepaticFunction.childPughClass !== 'C',
+              requiresDocumentation: true
+            });
+          }
+        }
+
+        // Check age-based adjustment
+        if (guideline.ageAdjustment) {
+          for (const adj of guideline.ageAdjustment) {
+            if (patient.demographics.age >= adj.ageThreshold) {
+              alerts.push({
+                id: `DOSE-AGE-${Date.now()}`,
+                type: 'dosing',
+                severity: 'low',
+                title: `Age-Based Consideration: ${drugOrder.drug}`,
+                description: `Patient age ${patient.demographics.age} may require adjustment`,
+                affectedDrugs: [drugOrder.drug],
+                recommendation: adj.adjustment,
+                overridable: true,
+                requiresDocumentation: false
+              });
+              break;
+            }
+          }
+        }
+      }
+    }
+
+    return alerts;
+  }
+
+  /**
+   * Check QT prolongation risk
+   */
+  async checkQTProlongation(drugs: string[], patient: PatientSafetyProfile): Promise<SafetyAlert[]> {
+    const alerts: SafetyAlert[] = [];
+    const qtDrugs = drugs.filter(d => this.qtProlongingDrugs.has(d.toLowerCase()));
+
+    if (qtDrugs.length > 0) {
+      // Check baseline QTc
+      const baselineQTc = patient.cardiacStatus.qtcInterval;
+      let riskLevel: 'critical' | 'high' | 'moderate' | 'low' = 'moderate';
+
+      if (baselineQTc && baselineQTc > 500) {
+        riskLevel = 'critical';
+      } else if (baselineQTc && baselineQTc > 470) {
+        riskLevel = 'high';
+      } else if (qtDrugs.length >= 2) {
+        riskLevel = 'high';
+      }
+
+      // Check for additional risk factors
+      const riskFactors: string[] = [];
+      if (patient.demographics.gender === 'female') riskFactors.push('Female gender');
+      if (patient.demographics.age > 65) riskFactors.push('Age > 65');
+      if (patient.cardiacStatus.arrhythmiaHistory) riskFactors.push('Arrhythmia history');
+      // Would also check electrolytes (K, Mg) if available
+
+      if (qtDrugs.length >= 2 || riskLevel === 'critical' || riskLevel === 'high') {
+        alerts.push({
+          id: `QT-${Date.now()}`,
+          type: 'qt-prolongation',
+          severity: riskLevel,
+          title: `QT Prolongation Risk: ${qtDrugs.join(', ')}`,
+          description: `${qtDrugs.length} QT-prolonging drug(s) ordered. ${riskFactors.length > 0 ? 'Risk factors: ' + riskFactors.join(', ') : ''}`,
+          affectedDrugs: qtDrugs,
+          recommendation: `Monitor QTc. Consider ECG at baseline and after steady state. Avoid if QTc > 500ms.`,
+          overridable: riskLevel !== 'critical',
+          requiresDocumentation: true
+        });
+      }
+    }
+
+    return alerts;
+  }
+
+  /**
+   * Check pregnancy and lactation safety
+   */
+  async checkPregnancySafety(
+    drugs: string[],
+    patient: PatientSafetyProfile
+  ): Promise<SafetyAlert[]> {
+    const alerts: SafetyAlert[] = [];
+
+    // Known teratogenic drugs
+    const categoryX: string[] = [
+      'methotrexate', 'thalidomide', 'lenalidomide', 'pomalidomide',
+      'isotretinoin', 'warfarin', 'ribavirin', 'leflunomide'
+    ];
+
+    const categoryD: string[] = [
+      'doxorubicin', 'cyclophosphamide', 'imatinib', 'tamoxifen',
+      'carbamazepine', 'phenytoin', 'valproic acid', 'lithium'
+    ];
+
+    for (const drug of drugs) {
+      const drugLower = drug.toLowerCase();
+
+      if (categoryX.some(x => drugLower.includes(x))) {
+        alerts.push({
+          id: `PREG-X-${Date.now()}`,
+          type: 'pregnancy',
+          severity: 'critical',
+          title: `Pregnancy Contraindication: ${drug}`,
+          description: `${drug} is absolutely contraindicated in pregnancy (Category X equivalent)`,
+          affectedDrugs: [drug],
+          recommendation: `Do not use. Use alternative therapy. Ensure contraception.`,
+          overridable: false,
+          requiresDocumentation: true
+        });
+      } else if (categoryD.some(d => drugLower.includes(d))) {
+        alerts.push({
+          id: `PREG-D-${Date.now()}`,
+          type: 'pregnancy',
+          severity: 'high',
+          title: `Pregnancy Risk: ${drug}`,
+          description: `${drug} has evidence of fetal risk but may be used if benefit outweighs risk`,
+          affectedDrugs: [drug],
+          recommendation: `Document informed consent. Discuss risks with patient. Consider alternatives.`,
+          overridable: true,
+          requiresDocumentation: true
+        });
+      }
+    }
+
+    return alerts;
+  }
+
+  /**
+   * Check black box warnings
+   */
+  async checkBlackBoxWarnings(drugs: string[]): Promise<SafetyAlert[]> {
+    const alerts: SafetyAlert[] = [];
+
+    for (const drug of drugs) {
+      const warnings = this.blackBoxWarnings.get(drug.toLowerCase());
+      if (warnings && warnings.length > 0) {
+        alerts.push({
+          id: `BBW-${Date.now()}`,
+          type: 'black-box',
+          severity: 'high',
+          title: `Black Box Warning: ${drug}`,
+          description: warnings.join('; '),
+          affectedDrugs: [drug],
+          recommendation: `Ensure appropriate monitoring and patient education. Document informed consent.`,
+          overridable: true,
+          requiresDocumentation: true
+        });
+      }
+    }
+
+    return alerts;
+  }
+
+  /**
+   * Check pharmacogenomic considerations
+   */
+  async checkPharmacogenomics(
+    drugs: string[],
+    genetics: NonNullable<PatientSafetyProfile['geneticFactors']>
+  ): Promise<SafetyAlert[]> {
+    const alerts: SafetyAlert[] = [];
+
+    // DPYD and fluoropyrimidines
+    if (genetics.dpyd && genetics.dpyd !== 'normal') {
+      const fluoropyrimidines = ['5-fu', 'fluorouracil', 'capecitabine'];
+      const affected = drugs.filter(d => fluoropyrimidines.some(f => d.toLowerCase().includes(f)));
+
+      if (affected.length > 0) {
+        const severity = genetics.dpyd === 'deficient' ? 'critical' : 'high';
+        alerts.push({
+          id: `PGX-DPYD-${Date.now()}`,
+          type: 'organ-function',
+          severity,
+          title: `DPYD Deficiency: ${affected.join(', ')}`,
+          description: `Patient is DPYD ${genetics.dpyd}. High risk of severe/fatal toxicity with fluoropyrimidines.`,
+          affectedDrugs: affected,
+          recommendation: genetics.dpyd === 'deficient'
+            ? 'Contraindicated. Use alternative therapy.'
+            : 'Reduce dose by 50%. Consider alternative.',
+          overridable: genetics.dpyd !== 'deficient',
+          requiresDocumentation: true
+        });
+      }
+    }
+
+    // UGT1A1 and irinotecan
+    if (genetics.ugt1a1 === '*28/*28') {
+      const irinotecan = drugs.filter(d => d.toLowerCase().includes('irinotecan'));
+      if (irinotecan.length > 0) {
+        alerts.push({
+          id: `PGX-UGT1A1-${Date.now()}`,
+          type: 'organ-function',
+          severity: 'high',
+          title: `UGT1A1 Polymorphism: Irinotecan`,
+          description: `Patient is UGT1A1*28/*28. Increased risk of severe neutropenia and diarrhea.`,
+          affectedDrugs: irinotecan,
+          recommendation: `Reduce initial dose by 1 level. Monitor closely.`,
+          overridable: true,
+          requiresDocumentation: true
+        });
+      }
+    }
+
+    // TPMT and thiopurines
+    if (genetics.tpmt && genetics.tpmt !== 'normal') {
+      const thiopurines = ['azathioprine', '6-mercaptopurine', 'thioguanine'];
+      const affected = drugs.filter(d => thiopurines.some(t => d.toLowerCase().includes(t)));
+
+      if (affected.length > 0) {
+        const severity = genetics.tpmt === 'poor' ? 'critical' : 'high';
+        alerts.push({
+          id: `PGX-TPMT-${Date.now()}`,
+          type: 'organ-function',
+          severity,
+          title: `TPMT Deficiency: ${affected.join(', ')}`,
+          description: `Patient is TPMT ${genetics.tpmt} metabolizer. Risk of severe myelosuppression.`,
+          affectedDrugs: affected,
+          recommendation: genetics.tpmt === 'poor'
+            ? 'Reduce dose by 90% or use alternative.'
+            : 'Reduce dose by 50%. Monitor CBC closely.',
+          overridable: genetics.tpmt !== 'poor',
+          requiresDocumentation: true
+        });
+      }
+    }
+
+    return alerts;
+  }
+
+  /**
+   * Get recommended alternatives for a contraindicated drug
+   */
+  getAlternatives(drug: string, reason: string, patientProfile: PatientSafetyProfile): string[] {
+    const alternatives: string[] = [];
+
+    // Drug class-based alternatives
+    const alternativeMap: Record<string, string[]> = {
+      // Chemotherapy
+      'cisplatin': ['carboplatin', 'oxaliplatin'],
+      'doxorubicin': ['liposomal doxorubicin', 'epirubicin'],
+      'ifosfamide': ['cyclophosphamide'],
+
+      // Targeted therapy
+      'osimertinib': ['afatinib', 'erlotinib', 'gefitinib'],
+      'alectinib': ['brigatinib', 'lorlatinib', 'crizotinib'],
+
+      // Immunotherapy (generally fewer direct alternatives)
+      'pembrolizumab': ['nivolumab', 'atezolizumab'],
+      'nivolumab': ['pembrolizumab', 'atezolizumab'],
+
+      // Supportive care
+      'ondansetron': ['granisetron', 'palonosetron'],
+      'metoclopramide': ['prochlorperazine', 'promethazine']
+    };
+
+    const drugLower = drug.toLowerCase();
+    for (const [key, alts] of Object.entries(alternativeMap)) {
+      if (drugLower.includes(key)) {
+        alternatives.push(...alts);
+        break;
+      }
+    }
+
+    // Filter alternatives based on patient's contraindications
+    return alternatives.filter(alt => {
+      const interaction = this.findInteraction(alt, drug);
+      if (interaction?.severity === 'contraindicated') return false;
+      return true;
+    });
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════════
+  // HELPER METHODS
+  // ═══════════════════════════════════════════════════════════════════════════════
+
+  private initializeDatabases(): void {
+    // Initialize drug interactions (simplified - production would have comprehensive database)
+    this.addInteraction({
+      drug1: 'pembrolizumab',
+      drug2: 'corticosteroids',
+      severity: 'moderate',
+      type: 'pharmacodynamic',
+      mechanism: 'High-dose corticosteroids may reduce immunotherapy efficacy',
+      clinicalEffect: 'Reduced antitumor immune response',
+      management: 'Use lowest effective steroid dose. Consider steroid-sparing agents for irAE management.',
+      documentation: 'established'
+    });
+
+    this.addInteraction({
+      drug1: 'warfarin',
+      drug2: 'capecitabine',
+      severity: 'major',
+      type: 'pharmacokinetic',
+      mechanism: 'Capecitabine inhibits CYP2C9, increasing warfarin effect',
+      clinicalEffect: 'Increased INR and bleeding risk',
+      management: 'Monitor INR closely. Consider LMWH alternative.',
+      documentation: 'established'
+    });
+
+    this.addInteraction({
+      drug1: 'osimertinib',
+      drug2: 'strong cyp3a4 inducers',
+      severity: 'major',
+      type: 'pharmacokinetic',
+      mechanism: 'CYP3A4 inducers decrease osimertinib exposure',
+      clinicalEffect: 'Reduced efficacy',
+      management: 'Avoid concomitant use with strong CYP3A4 inducers',
+      documentation: 'established'
+    });
+
+    // Initialize QT-prolonging drugs
+    const qtDrugs = [
+      'ondansetron', 'granisetron', 'haloperidol', 'droperidol',
+      'methadone', 'sotalol', 'amiodarone', 'dofetilide',
+      'ibutilide', 'quinidine', 'procainamide', 'disopyramide',
+      'arsenic trioxide', 'crizotinib', 'lapatinib', 'nilotinib',
+      'pazopanib', 'sunitinib', 'vandetanib', 'vemurafenib'
+    ];
+    qtDrugs.forEach(d => this.qtProlongingDrugs.add(d.toLowerCase()));
+
+    // Initialize black box warnings
+    this.blackBoxWarnings.set('pembrolizumab', [
+      'Immune-mediated adverse reactions can be severe and fatal',
+      'Monitor for immune-mediated pneumonitis, colitis, hepatitis, endocrinopathies, nephritis, and dermatologic reactions'
+    ]);
+
+    this.blackBoxWarnings.set('trastuzumab', [
+      'Cardiomyopathy: Evaluate LVEF prior to and during treatment',
+      'Infusion reactions including fatal cases'
+    ]);
+
+    this.blackBoxWarnings.set('bevacizumab', [
+      'Gastrointestinal perforation',
+      'Surgery and wound healing complications',
+      'Hemorrhage'
+    ]);
+
+    // Initialize allergy cross-reactivity
+    this.allergenCrossReactivity.set('penicillin', ['amoxicillin', 'ampicillin', 'piperacillin', 'cephalosporins']);
+    this.allergenCrossReactivity.set('sulfa', ['sulfamethoxazole', 'sulfasalazine', 'celecoxib', 'furosemide']);
+    this.allergenCrossReactivity.set('platinum', ['cisplatin', 'carboplatin', 'oxaliplatin']);
+
+    // Initialize dosing guidelines
+    this.dosingGuidelines.set('carboplatin', [{
+      drug: 'carboplatin',
+      indication: 'solid tumors',
+      standardDose: 'AUC 5-6 (Calvert formula)',
+      renalAdjustment: [
+        { gfrThreshold: 60, adjustment: 'Use Calvert formula with measured or estimated GFR' },
+        { gfrThreshold: 30, adjustment: 'Reduce target AUC. Consider nephrology consult' },
+        { gfrThreshold: 15, adjustment: 'Avoid or significant dose reduction' }
+      ],
+      weightBasedDosing: {
+        formula: 'Dose (mg) = Target AUC × (GFR + 25)',
+        maxDose: 'Cap GFR at 125 mL/min'
+      }
+    }]);
+
+    this.dosingGuidelines.set('cisplatin', [{
+      drug: 'cisplatin',
+      indication: 'solid tumors',
+      standardDose: '75-100 mg/m²',
+      renalAdjustment: [
+        { gfrThreshold: 60, adjustment: 'Standard dose with aggressive hydration' },
+        { gfrThreshold: 45, adjustment: 'Reduce dose 25-50%' },
+        { gfrThreshold: 30, adjustment: 'Avoid - use carboplatin alternative' }
+      ]
+    }]);
+  }
+
+  private addInteraction(interaction: DrugInteraction): void {
+    const key1 = interaction.drug1.toLowerCase();
+    const key2 = interaction.drug2.toLowerCase();
+
+    if (!this.interactionDatabase.has(key1)) {
+      this.interactionDatabase.set(key1, []);
+    }
+    if (!this.interactionDatabase.has(key2)) {
+      this.interactionDatabase.set(key2, []);
+    }
+
+    this.interactionDatabase.get(key1)!.push(interaction);
+    this.interactionDatabase.get(key2)!.push(interaction);
+  }
+
+  private findInteraction(drug1: string, drug2: string): DrugInteraction | null {
+    const interactions = this.interactionDatabase.get(drug1.toLowerCase());
+    if (!interactions) return null;
+
+    return interactions.find(i =>
+      i.drug2.toLowerCase() === drug2.toLowerCase() ||
+      i.drug1.toLowerCase() === drug2.toLowerCase()
+    ) || null;
+  }
+
+  private mapInteractionSeverity(severity: DrugInteraction['severity']): SafetyAlert['severity'] {
+    switch (severity) {
+      case 'contraindicated': return 'critical';
+      case 'major': return 'high';
+      case 'moderate': return 'moderate';
+      case 'minor': return 'low';
+    }
+  }
+
+  private checkCrossReactivity(allergen: string, drug: string): AllergyCheck {
+    const relatedAllergens = this.allergenCrossReactivity.get(allergen.toLowerCase()) || [];
+    const crossReacts = relatedAllergens.some(a => drug.toLowerCase().includes(a));
+
+    let riskLevel: AllergyCheck['riskLevel'] = 'none';
+    if (crossReacts) {
+      // Platinum cross-reactivity is high
+      if (allergen.toLowerCase().includes('platinum')) {
+        riskLevel = 'high';
+      }
+      // Penicillin-cephalosporin is lower risk
+      else if (allergen.toLowerCase().includes('penicillin') && drug.toLowerCase().includes('cephalosporin')) {
+        riskLevel = 'low'; // ~2% cross-reactivity
+      } else {
+        riskLevel = 'moderate';
+      }
+    }
+
+    return {
+      reportedAllergy: allergen,
+      drugToCheck: drug,
+      crossReactivity: crossReacts,
+      riskLevel,
+      relatedAllergens,
+      recommendation: crossReacts
+        ? `Consider alternative. If essential, administer with caution and monitor.`
+        : `No known cross-reactivity. Standard precautions.`
+    };
+  }
+
+  /**
+   * Generate a medication reconciliation report
+   */
+  async generateMedicationReconciliation(patient: PatientSafetyProfile): Promise<{
+    currentMedications: string[];
+    interactions: DrugInteraction[];
+    recommendations: string[];
+    summary: string;
+  }> {
+    const currentMeds = patient.currentMedications.map(m => m.drug);
+    const interactionAlerts = await this.checkDrugInteractions(currentMeds);
+
+    const interactions: DrugInteraction[] = [];
+    for (let i = 0; i < currentMeds.length; i++) {
+      for (let j = i + 1; j < currentMeds.length; j++) {
+        const int = this.findInteraction(currentMeds[i], currentMeds[j]);
+        if (int) interactions.push(int);
+      }
+    }
+
+    const recommendations: string[] = [];
+    for (const int of interactions.filter(i => i.severity === 'major' || i.severity === 'contraindicated')) {
+      recommendations.push(int.management);
+    }
+
+    return {
+      currentMedications: currentMeds,
+      interactions,
+      recommendations,
+      summary: interactions.length > 0
+        ? `Found ${interactions.length} drug interaction(s), including ${interactions.filter(i => i.severity === 'major' || i.severity === 'contraindicated').length} major interaction(s).`
+        : 'No significant drug interactions identified.'
+    };
+  }
+}
+
+export default DrugSafetyService;