@gefyra/diffyr6-cli 1.0.1 → 1.0.3

package/src/config.js

@@ -6,7 +6,7 @@ import { pathExists } from './utils/fs.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-export const CONFIG_VERSION = '1.0.0';
+export const CONFIG_VERSION = '1.0.1';
 
 /**
  * Default configuration values
@@ -24,6 +24,7 @@ export const DEFAULT_CONFIG = {
   validatorJarPath: null,
   workdir: null,
   compareMode: 'incremental',
+  exportZip: true,
 };
 
 /**
@@ -94,6 +95,10 @@ function validateConfig(config) {
   if (config.compareMode && !['incremental', 'full'].includes(config.compareMode)) {
     errors.push('compareMode must be either "incremental" or "full"');
   }
+
+  if (typeof config.exportZip !== 'boolean') {
+    errors.push('exportZip must be a boolean');
+  }
   
   if (errors.length > 0) {
     throw new Error(`Invalid configuration:\n${errors.map(e => `  - ${e}`).join('\n')}`);
@@ -106,7 +111,7 @@ function validateConfig(config) {
 export async function createExampleConfig(outputPath) {
   const example = {
     configVersion: CONFIG_VERSION,
-    packageId: 'de.basisprofil.r4#1.5.0',
+    packageId: 'de.basisprofil.r4',
     packageVersion: '1.5.0',
     enableGoFSH: true,
     resourcesDir: 'Resources',
@@ -116,7 +121,8 @@ export async function createExampleConfig(outputPath) {
     rulesConfigPath: null,
     validatorJarPath: null,
     workdir: null,
-    compareMode: 'incremental'
+    compareMode: 'incremental',
+    exportZip: true
   };
   
   await fsp.writeFile(

package/src/index.js

@@ -7,7 +7,9 @@ import { spawnProcess } from './utils/process.js';
 import { generateFshFromPackage } from './generate-fsh.js';
 import { upgradeSushiToR6 } from './upgrade-sushi.js';
 import { compareProfiles } from './compare-profiles.js';
+import { compareTerminology } from './compare-terminology.js';
 import { findRemovedResources } from './utils/removed-resources.js';
+import { createZip } from './utils/zip.js';
 
 /**
  * Main entry point - runs the FHIR R4 to R6 migration pipeline
@@ -37,46 +39,69 @@ export async function runMigration(config) {
   if (config.enableGoFSH) {
     const shouldRunGoFSH = await checkShouldRunGoFSH(resourcesDir);
     if (shouldRunGoFSH) {
-      console.log('\n[1/4] Downloading package and generating FSH...');
+      console.log('\n[1/5] Downloading package and generating FSH...');
       await runGoFSH(context);
       context.steps.push('gofsh');
     } else {
-      console.log('\n[1/4] GoFSH - SKIPPED (Resources directory with sushi-config.yaml already exists)');
+      console.log('\n[1/5] GoFSH - SKIPPED (Resources directory with sushi-config.yaml already exists)');
     }
   } else {
-    console.log('\n[1/4] GoFSH - DISABLED in config');
+    console.log('\n[1/5] GoFSH - DISABLED in config');
   }
   
   // Step 2: Upgrade to R6
   const shouldRunUpgrade = await checkShouldRunUpgrade(resourcesR6Dir);
   if (shouldRunUpgrade) {
-    console.log('\n[2/4] Upgrading to R6...');
+    console.log('\n[2/5] Upgrading to R6...');
     await runUpgradeToR6(context);
     context.steps.push('upgrade');
   } else {
-    console.log('\n[2/4] Upgrade - SKIPPED (ResourcesR6 directory with sushi-config.yaml already exists)');
+    console.log('\n[2/5] Upgrade - SKIPPED (ResourcesR6 directory with sushi-config.yaml already exists)');
   }
   
   // Step 3: Compare profiles
-  console.log('\n[3/4] Comparing R4 vs R6 profiles...');
+  console.log('\n[3/5] Comparing R4 vs R6 profiles...');
   const compareResults = await runProfileComparison(context);
   context.steps.push('compare');
   
-  // Step 4: Generate report with rules
-  console.log('\n[4/4] Generating migration report...');
+  // Step 4: Generat5] Generating migration report...');
   const removedResources = await findRemovedResources(resourcesDir);
   const report = await generateReport(context, compareResults, removedResources);
   context.steps.push('report');
+
+  // Step 5: Compare terminology bindings
+  console.log('\n[5/5] Comparing terminology bindings...');
+  let terminologyReport = null;
+  try {
+    terminologyReport = await runTerminologyComparison(context);
+    if (terminologyReport) {
+      context.steps.push('terminology');
+    }
+  } catch (error) {
+    console.warn(`  Terminology comparison failed: ${error.message}`);
+    console.warn('  Continuing without terminology report...');
+  }
+
+  let exportZipPath = null;
+  if (config.exportZip) {
+    console.log('\nGenerating export ZIP...');
+    exportZipPath = await exportComparisonZip(context, report, terminologyReport);
+    context.steps.push('exportZip');
+  }
   
   console.log(`\n✓ Migration complete!`);
   console.log(`  Report: ${report.path}`);
   console.log(`  Total Score: ${report.score}`);
   console.log(`  Findings: ${report.findingsCount}`);
+  if (exportZipPath) {
+    console.log(`  Export ZIP: ${exportZipPath}`);
+  }
   
   return {
     success: true,
     steps: context.steps,
     report: report.path,
+    exportZip: exportZipPath,
     score: report.score,
     findingsCount: report.findingsCount,
   };
@@ -141,6 +166,28 @@ async function runProfileComparison(context) {
   return [];
 }
 
+/**
+ * Run terminology comparison
+ */
+async function runTerminologyComparison(context) {
+  const { resourcesDir, resourcesR6Dir, outputDir, config } = context;
+  
+  const options = {
+    debug: config.debug || false,
+  };
+  
+  const result = await compareTerminology(resourcesDir, resourcesR6Dir, outputDir, options);
+  
+  if (result) {
+    console.log(`  ${result.profilesWithDifferences} profile(s) with binding differences`);
+    console.log(`  Total findings: ${result.totalFindings}`);
+    console.log(`  Markdown report: ${result.path}`);
+    console.log(`  JSON report: ${result.jsonPath}`);
+  }
+  
+  return result;
+}
+
 /**
  * Get list of profiles that need to be compared
  */
@@ -233,11 +280,87 @@ async function generateReport(context, compareResults, removedResources = []) {
   
   return {
     path: reportPath,
+    filename: reportFilename,
+    timestamp,
     score: totalScore,
     findingsCount: findings.length,
   };
 }
 
+/**
+ * Create a ZIP export with compare HTML files, report, and run config
+ */
+async function exportComparisonZip(context, report, terminologyReport = null) {
+  const { compareDir, outputDir, config } = context;
+  const exportFilename = 'diffyr6-publish.zip';
+  const exportPath = path.join(outputDir, exportFilename);
+
+  const entries = [];
+
+  // Add HTML comparison files sent to the API
+  const htmlFiles = await listExportHtmlFiles(compareDir);
+  for (const file of htmlFiles) {
+    const filePath = path.join(compareDir, file);
+    const content = await fsp.readFile(filePath);
+    entries.push({
+      name: file,
+      data: content,
+      mtime: (await fsp.stat(filePath)).mtime,
+    });
+  }
+
+  // Add markdown report
+  const reportContent = await fsp.readFile(report.path);
+  entries.push({
+    name: report.filename,
+    data: reportContent,
+    mtime: (await fsp.stat(report.path)).mtime,
+  });
+
+  // Add terminology report if available
+  if (terminologyReport && terminologyReport.path) {
+    const termContent = await fsp.readFile(terminologyReport.path);
+    entries.push({
+      name: terminologyReport.filename,
+      data: termContent,
+      mtime: (await fsp.stat(terminologyReport.path)).mtime,
+    });
+    
+    // Add terminology JSON if available
+    if (terminologyReport.jsonPath) {
+      const termJsonContent = await fsp.readFile(terminologyReport.jsonPath);
+      entries.push({
+        name: terminologyReport.jsonFilename,
+        data: termJsonContent,
+        mtime: (await fsp.stat(terminologyReport.jsonPath)).mtime,
+      });
+    }
+  }
+
+  // Add config used for the run
+  entries.push({
+    name: 'run-config.json',
+    data: JSON.stringify(config, null, 2),
+    mtime: new Date(),
+  });
+
+  await createZip(exportPath, entries);
+  return exportPath;
+}
+
+async function listExportHtmlFiles(compareDir) {
+  const exists = await directoryExists(compareDir);
+  if (!exists) {
+    return [];
+  }
+  const files = await fsp.readdir(compareDir);
+  const allowed = /^(sd|xx)-.+-.+\.html$/i;
+  const excluded = /(intersection|union)\.html$/i;
+  return files
+    .filter(file => allowed.test(file) && !excluded.test(file))
+    .sort();
+}
+
 /**
  * Read all HTML comparison files
  */

package/src/utils/zip.js

@@ -0,0 +1,112 @@
+import fsp from 'fs/promises';
+
+const CRC32_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let i = 0; i < 256; i += 1) {
+    let c = i;
+    for (let k = 0; k < 8; k += 1) {
+      c = (c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1);
+    }
+    table[i] = c >>> 0;
+  }
+  return table;
+})();
+
+function crc32(buffer) {
+  let crc = 0xFFFFFFFF;
+  for (let i = 0; i < buffer.length; i += 1) {
+    const byte = buffer[i];
+    crc = (crc >>> 8) ^ CRC32_TABLE[(crc ^ byte) & 0xFF];
+  }
+  return (crc ^ 0xFFFFFFFF) >>> 0;
+}
+
+function toDosDateTime(date) {
+  const d = date instanceof Date ? date : new Date(date);
+  let year = d.getFullYear();
+  if (year < 1980) {
+    year = 1980;
+  }
+  const month = d.getMonth() + 1;
+  const day = d.getDate();
+  const hours = d.getHours();
+  const minutes = d.getMinutes();
+  const seconds = Math.floor(d.getSeconds() / 2);
+  const dosTime = (hours << 11) | (minutes << 5) | seconds;
+  const dosDate = ((year - 1980) << 9) | (month << 5) | day;
+  return { dosTime, dosDate };
+}
+
+export async function createZip(outputPath, entries) {
+  const fileParts = [];
+  const centralParts = [];
+  let offset = 0;
+
+  for (const entry of entries) {
+    const name = entry.name.replace(/\\/g, '/');
+    const nameBuffer = Buffer.from(name, 'utf8');
+    const dataBuffer = Buffer.isBuffer(entry.data)
+      ? entry.data
+      : Buffer.from(entry.data, 'utf8');
+    const { dosTime, dosDate } = toDosDateTime(entry.mtime || new Date());
+    const crc = crc32(dataBuffer);
+    const size = dataBuffer.length;
+
+    const localHeader = Buffer.alloc(30 + nameBuffer.length);
+    let p = 0;
+    localHeader.writeUInt32LE(0x04034b50, p); p += 4; // Local file header signature
+    localHeader.writeUInt16LE(20, p); p += 2; // Version needed
+    localHeader.writeUInt16LE(0, p); p += 2; // Flags
+    localHeader.writeUInt16LE(0, p); p += 2; // Compression (store)
+    localHeader.writeUInt16LE(dosTime, p); p += 2;
+    localHeader.writeUInt16LE(dosDate, p); p += 2;
+    localHeader.writeUInt32LE(crc, p); p += 4;
+    localHeader.writeUInt32LE(size, p); p += 4;
+    localHeader.writeUInt32LE(size, p); p += 4;
+    localHeader.writeUInt16LE(nameBuffer.length, p); p += 2;
+    localHeader.writeUInt16LE(0, p); p += 2; // Extra length
+    nameBuffer.copy(localHeader, p);
+
+    fileParts.push(localHeader, dataBuffer);
+
+    const centralHeader = Buffer.alloc(46 + nameBuffer.length);
+    p = 0;
+    centralHeader.writeUInt32LE(0x02014b50, p); p += 4; // Central dir signature
+    centralHeader.writeUInt16LE(20, p); p += 2; // Version made by
+    centralHeader.writeUInt16LE(20, p); p += 2; // Version needed
+    centralHeader.writeUInt16LE(0, p); p += 2; // Flags
+    centralHeader.writeUInt16LE(0, p); p += 2; // Compression
+    centralHeader.writeUInt16LE(dosTime, p); p += 2;
+    centralHeader.writeUInt16LE(dosDate, p); p += 2;
+    centralHeader.writeUInt32LE(crc, p); p += 4;
+    centralHeader.writeUInt32LE(size, p); p += 4;
+    centralHeader.writeUInt32LE(size, p); p += 4;
+    centralHeader.writeUInt16LE(nameBuffer.length, p); p += 2;
+    centralHeader.writeUInt16LE(0, p); p += 2; // Extra length
+    centralHeader.writeUInt16LE(0, p); p += 2; // Comment length
+    centralHeader.writeUInt16LE(0, p); p += 2; // Disk number
+    centralHeader.writeUInt16LE(0, p); p += 2; // Internal attributes
+    centralHeader.writeUInt32LE(0, p); p += 4; // External attributes
+    centralHeader.writeUInt32LE(offset, p); p += 4; // Local header offset
+    nameBuffer.copy(centralHeader, p);
+
+    centralParts.push(centralHeader);
+    offset += localHeader.length + dataBuffer.length;
+  }
+
+  const centralDirSize = centralParts.reduce((sum, buf) => sum + buf.length, 0);
+  const centralDirOffset = offset;
+  const endRecord = Buffer.alloc(22);
+  let e = 0;
+  endRecord.writeUInt32LE(0x06054b50, e); e += 4; // End of central dir signature
+  endRecord.writeUInt16LE(0, e); e += 2; // Disk number
+  endRecord.writeUInt16LE(0, e); e += 2; // Central dir start disk
+  endRecord.writeUInt16LE(entries.length, e); e += 2; // Entries on disk
+  endRecord.writeUInt16LE(entries.length, e); e += 2; // Total entries
+  endRecord.writeUInt32LE(centralDirSize, e); e += 4;
+  endRecord.writeUInt32LE(centralDirOffset, e); e += 4;
+  endRecord.writeUInt16LE(0, e); e += 2; // Comment length
+
+  const buffer = Buffer.concat([...fileParts, ...centralParts, endRecord]);
+  await fsp.writeFile(outputPath, buffer);
+}