@gefyra/diffyr6-cli 1.0.2 → 1.1.0

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.1';
+export const CONFIG_VERSION = '1.0.2';
 
 /**
  * Default configuration values
@@ -25,6 +25,7 @@ export const DEFAULT_CONFIG = {
   workdir: null,
   compareMode: 'incremental',
   exportZip: true,
+  skipTerminologyReport: false,
 };
 
 /**
@@ -32,7 +33,17 @@ export const DEFAULT_CONFIG = {
  */
 export async function loadConfig(configPath) {
   const raw = await fsp.readFile(configPath, 'utf8');
-  const config = JSON.parse(raw);
+  let config = JSON.parse(raw);
+  const originalVersion = config.configVersion;
+  
+  // Migrate config if needed
+  config = migrateConfig(config);
+  
+  // Write back to file if migration occurred
+  if (config.configVersion !== originalVersion) {
+    await fsp.writeFile(configPath, JSON.stringify(config, null, 2), 'utf8');
+    console.log(`  Config file updated to version ${config.configVersion}`);
+  }
   
   // Validate config version
   validateConfigVersion(config);
@@ -46,6 +57,34 @@ export async function loadConfig(configPath) {
   return merged;
 }
 
+/**
+ * Migrates configuration from older versions to the current version
+ */
+function migrateConfig(config) {
+  if (!config.configVersion) {
+    // Very old config without version - add all new fields
+    console.log('  Migrating config from pre-1.0.0 to current version...');
+    config.configVersion = CONFIG_VERSION;
+    if (config.skipTerminologyReport === undefined) {
+      config.skipTerminologyReport = false;
+    }
+    return config;
+  }
+  
+  const [major, minor, patch] = config.configVersion.split('.').map(Number);
+  
+  // Migrate from 1.0.0 or 1.0.1 to 1.0.2
+  if (major === 1 && minor === 0 && (patch === 0 || patch === 1)) {
+    console.log(`  Migrating config from ${config.configVersion} to ${CONFIG_VERSION}...`);
+    if (config.skipTerminologyReport === undefined) {
+      config.skipTerminologyReport = false;
+    }
+    config.configVersion = CONFIG_VERSION;
+  }
+  
+  return config;
+}
+
 /**
  * Validates the configuration version
  */
@@ -99,6 +138,10 @@ function validateConfig(config) {
   if (typeof config.exportZip !== 'boolean') {
     errors.push('exportZip must be a boolean');
   }
+
+  if (typeof config.skipTerminologyReport !== 'boolean') {
+    errors.push('skipTerminologyReport must be a boolean');
+  }
   
   if (errors.length > 0) {
     throw new Error(`Invalid configuration:\n${errors.map(e => `  - ${e}`).join('\n')}`);
@@ -122,7 +165,8 @@ export async function createExampleConfig(outputPath) {
     validatorJarPath: null,
     workdir: null,
     compareMode: 'incremental',
-    exportZip: true
+    exportZip: true,
+    skipTerminologyReport: false
   };
   
   await fsp.writeFile(

package/src/index.js

@@ -7,13 +7,18 @@ 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, hasSnapshots, runSushiWithSnapshots } from './compare-terminology.js';
 import { findRemovedResources } from './utils/removed-resources.js';
 import { createZip } from './utils/zip.js';
+import { checkForUpdates } from './utils/update-check.js';
 
 /**
  * Main entry point - runs the FHIR R4 to R6 migration pipeline
  */
 export async function runMigration(config) {
+  // Check for updates
+  await checkForUpdates();
+  
   // Resolve paths
   const workdir = config.workdir ? path.resolve(config.workdir) : process.cwd();
   const resourcesDir = path.resolve(workdir, config.resourcesDir);
@@ -38,41 +43,62 @@ 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/6] 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/6] GoFSH - SKIPPED (Resources directory with sushi-config.yaml already exists)');
     }
   } else {
-    console.log('\n[1/4] GoFSH - DISABLED in config');
+    console.log('\n[1/6] 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/6] 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/6] Upgrade - SKIPPED (ResourcesR6 directory with sushi-config.yaml already exists)');
   }
   
-  // Step 3: Compare profiles
-  console.log('\n[3/4] Comparing R4 vs R6 profiles...');
+  // Step 3: Build snapshots for both R4 and R6
+  console.log('\n[3/6] Building snapshots with SUSHI...');
+  await runSnapshotBuild(context);
+  context.steps.push('snapshots');
+  
+  // Step 4: Compare profiles
+  console.log('\n[4/6] 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 5: Generat6] Generating migration report...');
   const removedResources = await findRemovedResources(resourcesDir);
   const report = await generateReport(context, compareResults, removedResources);
   context.steps.push('report');
 
+  // Step 6: Compare terminology bindings
+  let terminologyReport = null;
+  if (config.skipTerminologyReport) {
+    console.log('\n[6/6] Terminology comparison - SKIPPED (skipTerminologyReport is enabled)');
+  } else {
+    console.log('\n[6/6] Comparing terminology bindings...');
+    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);
+    exportZipPath = await exportComparisonZip(context, report, terminologyReport);
     context.steps.push('exportZip');
   }
   
@@ -131,6 +157,44 @@ async function runUpgradeToR6(context) {
   await upgradeSushiToR6(resourcesDir, sushiExecutable);
 }
 
+/**
+ * Build snapshots for both R4 and R6 projects with sushi -s
+ */
+async function runSnapshotBuild(context) {
+  const { resourcesDir, resourcesR6Dir, config } = context;
+  const debug = config.debug || false;
+  
+  console.log('  Checking for existing snapshots...');
+  
+  const resourcesDirHasSnapshots = await hasSnapshots(resourcesDir);
+  const resourcesR6DirHasSnapshots = await hasSnapshots(resourcesR6Dir);
+  
+  if (resourcesDirHasSnapshots && resourcesR6DirHasSnapshots) {
+    console.log('  Snapshots already exist in both directories, skipping SUSHI build');
+    return;
+  }
+  
+  console.log('  Building snapshots with SUSHI...');
+  
+  try {
+    if (!resourcesDirHasSnapshots) {
+      await runSushiWithSnapshots(resourcesDir, debug);
+    } else {
+      console.log(`  Skipping ${path.basename(resourcesDir)} (snapshots already exist)`);
+    }
+    
+    if (!resourcesR6DirHasSnapshots) {
+      await runSushiWithSnapshots(resourcesR6Dir, debug);
+    } else {
+      console.log(`  Skipping ${path.basename(resourcesR6Dir)} (snapshots already exist)`);
+    }
+    
+    console.log('  Snapshots built successfully');
+  } catch (error) {
+    throw new Error(`Failed to build snapshots: ${error.message}`);
+  }
+}
+
 /**
  * Run profile comparison
  */
@@ -153,6 +217,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
  */
@@ -255,7 +341,7 @@ async function generateReport(context, compareResults, removedResources = []) {
 /**
  * Create a ZIP export with compare HTML files, report, and run config
  */
-async function exportComparisonZip(context, report) {
+async function exportComparisonZip(context, report, terminologyReport = null) {
   const { compareDir, outputDir, config } = context;
   const exportFilename = 'diffyr6-publish.zip';
   const exportPath = path.join(outputDir, exportFilename);
@@ -282,6 +368,26 @@ async function exportComparisonZip(context, report) {
     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',

package/src/upgrade-sushi.js

@@ -7,7 +7,7 @@ import { parseSushiLog } from './utils/sushi-log.js';
 
 const SOURCE_VERSION = '4.0.1';
 const TARGET_VERSION = '6.0.0-ballot3';
-const MAX_ITERATIONS = 25;
+const MAX_ITERATIONS = 10;
 const SNOMED_CT_ERROR_TEXT = 'Resolved value "SNOMED_CT" is not a valid URI';
 
 /**
@@ -248,7 +248,11 @@ async function runSushiUntilSuccess(targetDir, sushiExecutable) {
     }
     console.log(`  Commented out lines in ${modifications} file(s)`);
   }
-  throw new Error(`SUSHI failed after ${MAX_ITERATIONS} attempts`);
+  throw new Error(
+    `SUSHI failed after ${MAX_ITERATIONS} iterations. ` +
+    `Please fix the remaining SUSHI errors manually in the ResourcesR6 directory ` +
+    `and then run 'sushi -s' to build the snapshots.`
+  );
 }
 
 async function runSushi(executable, targetDir) {
@@ -371,6 +375,69 @@ function expandContainsBlockLines(lines, lineNumbers) {
 
     const currentLine = lines[idx].trim();
     
+    // Handle multi-line string literals (e.g., ^comment, ^description, etc.)
+    // Check if line contains = followed by a quote that's not closed
+    const hasStringAssignment = currentLine.match(/=\s*(""")?(")?/);
+    if (hasStringAssignment) {
+      const tripleQuote = hasStringAssignment[1]; // """
+      const singleQuote = hasStringAssignment[2]; // "
+      
+      if (tripleQuote) {
+        // Triple-quoted string - find closing """
+        const firstTriplePos = currentLine.indexOf('"""');
+        const secondTriplePos = currentLine.indexOf('"""', firstTriplePos + 3);
+        
+        if (secondTriplePos === -1) {
+          // No closing """ on this line - include following lines
+          let nextIdx = idx + 1;
+          while (nextIdx < lines.length) {
+            expanded.add(nextIdx + 1);
+            if (lines[nextIdx].includes('"""')) {
+              break;
+            }
+            nextIdx++;
+            // Safety limit to prevent infinite loops
+            if (nextIdx - idx > 100) break;
+          }
+        }
+      } else if (singleQuote) {
+        // Single-quoted string - check if it's closed on the same line
+        const firstQuotePos = currentLine.indexOf('"');
+        let secondQuotePos = -1;
+        
+        // Find closing quote that's not escaped
+        for (let i = firstQuotePos + 1; i < currentLine.length; i++) {
+          if (currentLine[i] === '"' && currentLine[i - 1] !== '\\') {
+            secondQuotePos = i;
+            break;
+          }
+        }
+        
+        if (secondQuotePos === -1) {
+          // No closing " on this line - include following lines
+          let nextIdx = idx + 1;
+          while (nextIdx < lines.length) {
+            expanded.add(nextIdx + 1);
+            // Check for unescaped closing quote
+            const nextLine = lines[nextIdx];
+            let foundClosing = false;
+            for (let i = 0; i < nextLine.length; i++) {
+              if (nextLine[i] === '"' && (i === 0 || nextLine[i - 1] !== '\\')) {
+                foundClosing = true;
+                break;
+              }
+            }
+            if (foundClosing) {
+              break;
+            }
+            nextIdx++;
+            // Safety limit to prevent infinite loops
+            if (nextIdx - idx > 100) break;
+          }
+        }
+      }
+    }
+    
     if (currentLine.includes(' contains') || currentLine.endsWith(' and')) {
       let nextIdx = idx + 1;
       while (nextIdx < lines.length) {

package/src/utils/update-check.js

@@ -0,0 +1,128 @@
+import https from 'https';
+import { fileURLToPath } from 'url';
+import { readFileSync } from 'fs';
+import path from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Gets the current package version from package.json
+ */
+function getCurrentVersion() {
+  const packageJsonPath = path.join(__dirname, '..', '..', 'package.json');
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+  return packageJson.version;
+}
+
+/**
+ * Fetches the latest version from NPM registry
+ */
+function getLatestVersion(packageName) {
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: 'registry.npmjs.org',
+      port: 443,
+      path: `/${packageName}`,
+      method: 'GET',
+      headers: {
+        'Accept': 'application/json',
+      },
+      timeout: 3000,
+    };
+
+    const req = https.request(options, (res) => {
+      let data = '';
+
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      res.on('end', () => {
+        try {
+          if (res.statusCode === 200) {
+            const json = JSON.parse(data);
+            resolve(json['dist-tags']?.latest || null);
+          } else {
+            resolve(null);
+          }
+        } catch (error) {
+          resolve(null);
+        }
+      });
+    });
+
+    req.on('error', () => {
+      resolve(null);
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      resolve(null);
+    });
+
+    req.end();
+  });
+}
+
+/**
+ * Compares two semantic versions
+ * Returns true if newVersion is greater than currentVersion
+ */
+function isNewerVersion(currentVersion, newVersion) {
+  if (!currentVersion || !newVersion) return false;
+  
+  const current = currentVersion.split('.').map(Number);
+  const latest = newVersion.split('.').map(Number);
+  
+  for (let i = 0; i < 3; i++) {
+    if (latest[i] > current[i]) return true;
+    if (latest[i] < current[i]) return false;
+  }
+  
+  return false;
+}
+
+/**
+ * Creates a boxed update notification message
+ */
+function createUpdateNotification(currentVersion, latestVersion, packageName) {
+  const lines = [
+    '',
+    '╔════════════════════════════════════════════════════════════════╗',
+    '║                                                                ║',
+    '║                   UPDATE AVAILABLE                            ║',
+    '║                                                                ║',
+    `║  Current version: ${currentVersion.padEnd(43)} ║`,
+    `║  Latest version:  ${latestVersion.padEnd(43)} ║`,
+    '║                                                                ║',
+    '║  Run one of the following commands to update:                 ║',
+    '║                                                                ║',
+    `║  npm update -g ${packageName.padEnd(42)} ║`,
+    `║  npm install -g ${packageName}@latest`.padEnd(65) + '║',
+    '║                                                                ║',
+    '╚════════════════════════════════════════════════════════════════╝',
+    '',
+  ];
+  
+  return lines.join('\n');
+}
+
+/**
+ * Checks for updates and displays notification if available
+ * This function is non-blocking and will not throw errors
+ */
+export async function checkForUpdates() {
+  try {
+    const packageName = '@gefyra/diffyr6-cli';
+    const currentVersion = getCurrentVersion();
+    const latestVersion = await getLatestVersion(packageName);
+    
+    if (latestVersion && isNewerVersion(currentVersion, latestVersion)) {
+      const notification = createUpdateNotification(currentVersion, latestVersion, packageName);
+      console.log(notification);
+    }
+  } catch (error) {
+    // Silently fail - update check should never block the main functionality
+  }
+}