@gefyra/diffyr6-cli 1.1.4 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gefyra/diffyr6-cli",
-  "version": "1.1.4",
+  "version": "1.2.0",
   "description": "FHIR R4 to R6 migration pipeline runner with automated profile comparison and rule-based analysis",
   "main": "src/index.js",
   "type": "module",

package/src/compare-searchparameters.js

@@ -0,0 +1,328 @@
+import fsp from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function compareSearchParameters(resourcesDir, outputDir, options = {}) {
+  const { debug = false } = options;
+
+  if (debug) {
+    console.log('  Scanning CapabilityStatements for removed search parameters...');
+  }
+
+  const removedParams = await loadRemovedSearchParameters();
+  const capabilityStatements = await collectCapabilityStatements(resourcesDir);
+  const usedParams = extractUsedSearchParameters(capabilityStatements);
+  const matches = findRemovedMatches(usedParams, removedParams);
+
+  const timestamp = new Date().toISOString().replace(/[-:]/g, '').replace(/\..+/, '').replace('T', '-');
+  const reportFilename = `searchparameter-report-${timestamp}.md`;
+  const reportPath = path.join(outputDir, reportFilename);
+  const jsonFilename = `searchparameter-report-${timestamp}.json`;
+  const jsonPath = path.join(outputDir, jsonFilename);
+
+  const markdown = generateSearchParameterReport(matches);
+  await fsp.writeFile(reportPath, markdown, 'utf8');
+
+  const affectedCapabilityStatements = new Set(
+    matches.map(match => match.capabilityStatement.id || match.capabilityStatement.url || match.capabilityStatement.sourceFile)
+  );
+  const jsonData = {
+    generated: new Date().toISOString(),
+    totalRemovedMatches: matches.length,
+    affectedCapabilityStatements: affectedCapabilityStatements.size,
+    matches,
+  };
+  await fsp.writeFile(jsonPath, JSON.stringify(jsonData, null, 2), 'utf8');
+
+  return {
+    path: reportPath,
+    filename: reportFilename,
+    jsonPath,
+    jsonFilename,
+    matchCount: matches.length,
+    affectedCpsCount: affectedCapabilityStatements.size,
+  };
+}
+
+async function loadRemovedSearchParameters() {
+  const configPath = path.resolve(__dirname, '..', 'config', 'searchparameters-r4-not-in-r6.json');
+  const content = await fsp.readFile(configPath, 'utf8');
+  const data = JSON.parse(content);
+  return data.searchParameters || [];
+}
+
+async function collectCapabilityStatements(resourcesDir) {
+  const files = await collectJsonFiles(resourcesDir);
+  const capabilityStatements = [];
+  const baseDir = path.resolve(resourcesDir);
+
+  for (const filePath of files) {
+    const raw = await fsp.readFile(filePath, 'utf8').catch(() => '');
+    if (!raw) {
+      continue;
+    }
+
+    let data;
+    try {
+      data = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+
+    if (data?.resourceType !== 'CapabilityStatement') {
+      continue;
+    }
+
+    capabilityStatements.push({
+      id: data.id || '',
+      url: data.url || '',
+      name: data.name || data.title || data.id || path.basename(filePath, '.json'),
+      sourceFile: path.relative(baseDir, filePath) || path.basename(filePath),
+      data,
+    });
+  }
+
+  return capabilityStatements;
+}
+
+function extractUsedSearchParameters(capabilityStatements) {
+  const used = [];
+
+  for (const capabilityStatement of capabilityStatements) {
+    const restEntries = Array.isArray(capabilityStatement.data.rest) ? capabilityStatement.data.rest : [];
+
+    for (const rest of restEntries) {
+      const resources = Array.isArray(rest.resource) ? rest.resource : [];
+
+      for (const resource of resources) {
+        const resourceType = typeof resource.type === 'string' ? resource.type : '';
+        const searchParams = Array.isArray(resource.searchParam) ? resource.searchParam : [];
+
+        for (const searchParam of searchParams) {
+          const name = normalizeString(searchParam.name || searchParam.code);
+          const definition = normalizeString(searchParam.definition);
+
+          if (!name && !definition) {
+            continue;
+          }
+
+          used.push({
+            name,
+            definition,
+            resourceType,
+            capabilityStatementId: capabilityStatement.id,
+            capabilityStatementUrl: capabilityStatement.url,
+            capabilityStatementName: capabilityStatement.name,
+            sourceFile: capabilityStatement.sourceFile,
+          });
+        }
+      }
+    }
+  }
+
+  return used;
+}
+
+function findRemovedMatches(usedParams, removedParams) {
+  const removedByUrl = new Map();
+  const removedByBaseAndCode = new Map();
+
+  for (const removed of removedParams) {
+    const url = normalizeString(removed.url);
+    if (url) {
+      removedByUrl.set(url, removed);
+    }
+
+    const bases = Array.isArray(removed.base) ? removed.base : [];
+    for (const base of bases) {
+      const key = buildBaseCodeKey(base, removed.code || removed.name);
+      if (!key) {
+        continue;
+      }
+      if (!removedByBaseAndCode.has(key)) {
+        removedByBaseAndCode.set(key, []);
+      }
+      removedByBaseAndCode.get(key).push(removed);
+    }
+  }
+
+  const seen = new Set();
+  const matches = [];
+
+  for (const used of usedParams) {
+    let removed = null;
+    let matchedBy = '';
+
+    if (used.definition && removedByUrl.has(used.definition)) {
+      removed = removedByUrl.get(used.definition);
+      matchedBy = 'definition';
+    } else if (used.resourceType && used.name) {
+      const fallbackMatches = removedByBaseAndCode.get(buildBaseCodeKey(used.resourceType, used.name)) || [];
+      if (fallbackMatches.length > 0) {
+        removed = fallbackMatches[0];
+        matchedBy = 'name+base';
+      }
+    }
+
+    if (!removed) {
+      continue;
+    }
+
+    const matchKey = [
+      removed.url || removed.id || removed.code,
+      used.capabilityStatementId || used.capabilityStatementUrl || used.sourceFile,
+      used.resourceType,
+      used.name,
+      used.definition,
+    ].join('::').toLowerCase();
+
+    if (seen.has(matchKey)) {
+      continue;
+    }
+    seen.add(matchKey);
+
+    matches.push({
+      removedSearchParameter: {
+        id: removed.id || '',
+        name: removed.name || '',
+        code: removed.code || '',
+        url: removed.url || '',
+        base: Array.isArray(removed.base) ? removed.base : [],
+        type: removed.type || '',
+        description: removed.description || '',
+      },
+      capabilityStatement: {
+        id: used.capabilityStatementId || '',
+        url: used.capabilityStatementUrl || '',
+        name: used.capabilityStatementName || '',
+        sourceFile: used.sourceFile,
+      },
+      resourceType: used.resourceType,
+      searchParameter: {
+        name: used.name,
+        definition: used.definition,
+      },
+      matchedBy,
+    });
+  }
+
+  return matches.sort(compareMatches);
+}
+
+function generateSearchParameterReport(matches) {
+  const lines = [];
+  const generated = new Date().toISOString();
+  const affectedCapabilityStatements = new Set(
+    matches.map(match => match.capabilityStatement.id || match.capabilityStatement.url || match.capabilityStatement.sourceFile)
+  );
+
+  lines.push('# Search Parameter Report');
+  lines.push('');
+  lines.push(`**Generated:** ${generated}`);
+  lines.push(`**Removed search parameter matches:** ${matches.length}`);
+  lines.push(`**Affected CapabilityStatements:** ${affectedCapabilityStatements.size}`);
+  lines.push('');
+  lines.push('---');
+  lines.push('');
+
+  if (matches.length === 0) {
+    lines.push('No CapabilityStatements were found that reference search parameters removed in FHIR R6.');
+    lines.push('');
+    return lines.join('\n');
+  }
+
+  const grouped = new Map();
+  for (const match of matches) {
+    const key = match.removedSearchParameter.url || `${match.removedSearchParameter.code}::${match.resourceType}`;
+    if (!grouped.has(key)) {
+      grouped.set(key, []);
+    }
+    grouped.get(key).push(match);
+  }
+
+  for (const key of Array.from(grouped.keys()).sort()) {
+    const group = grouped.get(key);
+    const first = group[0];
+    const removed = first.removedSearchParameter;
+
+    lines.push(`## ${removed.code || removed.name || removed.id}`);
+    lines.push('');
+    lines.push(`**Resource Type:** ${(removed.base || []).join(', ') || first.resourceType || 'Unknown'}`);
+    lines.push(`**Definition:** ${removed.url || 'n/a'}`);
+    lines.push(`**Matches:** ${group.length}`);
+    if (removed.description) {
+      lines.push(`**Description:** ${removed.description}`);
+    }
+    lines.push('');
+    lines.push('Affected CapabilityStatements:');
+    lines.push('');
+
+    for (const match of group) {
+      const cpsLabel =
+        match.capabilityStatement.name ||
+        match.capabilityStatement.id ||
+        match.capabilityStatement.url ||
+        path.basename(match.capabilityStatement.sourceFile);
+      lines.push(`- **${cpsLabel}**`);
+      lines.push(`  Resource: ${match.resourceType || 'Unknown'}`);
+      lines.push(`  Parameter: ${match.searchParameter.name || 'n/a'}`);
+      lines.push(`  Match: ${match.matchedBy}`);
+      if (match.searchParameter.definition) {
+        lines.push(`  Definition: ${match.searchParameter.definition}`);
+      }
+      lines.push(`  Source: ${match.capabilityStatement.sourceFile}`);
+    }
+
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+async function collectJsonFiles(dir) {
+  const results = [];
+  const entries = await fsp.readdir(dir, { withFileTypes: true }).catch(() => []);
+
+  for (const entry of entries) {
+    const entryPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const nested = await collectJsonFiles(entryPath);
+      results.push(...nested);
+      continue;
+    }
+    if (entry.isFile() && entry.name.toLowerCase().endsWith('.json')) {
+      results.push(entryPath);
+    }
+  }
+
+  return results;
+}
+
+function buildBaseCodeKey(base, code) {
+  const normalizedBase = normalizeString(base);
+  const normalizedCode = normalizeString(code);
+  if (!normalizedBase || !normalizedCode) {
+    return '';
+  }
+  return `${normalizedBase}::${normalizedCode}`;
+}
+
+function normalizeString(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function compareMatches(a, b) {
+  return (
+    compareStrings(a.removedSearchParameter.code, b.removedSearchParameter.code) ||
+    compareStrings(a.resourceType, b.resourceType) ||
+    compareStrings(a.capabilityStatement.name || a.capabilityStatement.id, b.capabilityStatement.name || b.capabilityStatement.id) ||
+    compareStrings(a.searchParameter.name, b.searchParameter.name)
+  );
+}
+
+function compareStrings(a, b) {
+  return (a || '').localeCompare(b || '');
+}

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.2';
+export const CONFIG_VERSION = '1.0.3';
 
 /**
  * Default configuration values
@@ -26,6 +26,7 @@ export const DEFAULT_CONFIG = {
   compareMode: 'incremental',
   exportZip: true,
   skipTerminologyReport: false,
+  skipSearchParameterReport: false,
 };
 
 /**
@@ -68,17 +69,31 @@ function migrateConfig(config) {
     if (config.skipTerminologyReport === undefined) {
       config.skipTerminologyReport = false;
     }
+    if (config.skipSearchParameterReport === undefined) {
+      config.skipSearchParameterReport = 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
+  // Migrate from 1.0.0 or 1.0.1 to 1.0.2/1.0.3
   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;
     }
+    if (config.skipSearchParameterReport === undefined) {
+      config.skipSearchParameterReport = false;
+    }
+    config.configVersion = CONFIG_VERSION;
+  }
+
+  if (major === 1 && minor === 0 && patch === 2) {
+    console.log(`  Migrating config from ${config.configVersion} to ${CONFIG_VERSION}...`);
+    if (config.skipSearchParameterReport === undefined) {
+      config.skipSearchParameterReport = false;
+    }
     config.configVersion = CONFIG_VERSION;
   }
   
@@ -142,6 +157,10 @@ function validateConfig(config) {
   if (typeof config.skipTerminologyReport !== 'boolean') {
     errors.push('skipTerminologyReport must be a boolean');
   }
+
+  if (typeof config.skipSearchParameterReport !== 'boolean') {
+    errors.push('skipSearchParameterReport must be a boolean');
+  }
   
   if (errors.length > 0) {
     throw new Error(`Invalid configuration:\n${errors.map(e => `  - ${e}`).join('\n')}`);
@@ -166,7 +185,8 @@ export async function createExampleConfig(outputPath) {
     workdir: null,
     compareMode: 'incremental',
     exportZip: true,
-    skipTerminologyReport: false
+    skipTerminologyReport: false,
+    skipSearchParameterReport: false
   };
   
   await fsp.writeFile(

package/src/index.js

@@ -8,6 +8,7 @@ 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 { compareSearchParameters } from './compare-searchparameters.js';
 import { findRemovedResources } from './utils/removed-resources.js';
 import { createZip } from './utils/zip.js';
 import { checkForUpdates } from './utils/update-check.js';
@@ -38,42 +39,45 @@ export async function runMigration(config) {
     outputDir,
     steps: [],
   };
+
+  const totalSteps = 7;
   
   // Step 1: GoFSH (if enabled and not already done)
   if (config.enableGoFSH) {
     const shouldRunGoFSH = await checkShouldRunGoFSH(resourcesDir);
     if (shouldRunGoFSH) {
-      console.log('\n[1/6] Downloading package and generating FSH...');
+      console.log(`\n[1/${totalSteps}] Downloading package and generating FSH...`);
       await runGoFSH(context);
       context.steps.push('gofsh');
     } else {
-      console.log('\n[1/6] GoFSH - SKIPPED (Resources directory with sushi-config.yaml already exists)');
+      console.log(`\n[1/${totalSteps}] GoFSH - SKIPPED (Resources directory with sushi-config.yaml already exists)`);
     }
   } else {
-    console.log('\n[1/6] GoFSH - DISABLED in config');
+    console.log(`\n[1/${totalSteps}] GoFSH - DISABLED in config`);
   }
   
   // Step 2: Upgrade to R6
   const shouldRunUpgrade = await checkShouldRunUpgrade(resourcesR6Dir);
   if (shouldRunUpgrade) {
-    console.log('\n[2/6] Upgrading to R6...');
+    console.log(`\n[2/${totalSteps}] Upgrading to R6...`);
     await runUpgradeToR6(context);
     context.steps.push('upgrade');
   } else {
-    console.log('\n[2/6] Upgrade - SKIPPED (ResourcesR6 directory with sushi-config.yaml already exists)');
+    console.log(`\n[2/${totalSteps}] Upgrade - SKIPPED (ResourcesR6 directory with sushi-config.yaml already exists)`);
   }
   
   // Step 3: Build snapshots for both R4 and R6
-  console.log('\n[3/6] Building snapshots with SUSHI...');
+  console.log(`\n[3/${totalSteps}] 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...');
+  console.log(`\n[4/${totalSteps}] Comparing R4 vs R6 profiles...`);
   const compareResults = await runProfileComparison(context);
   context.steps.push('compare');
   
-  // Step 5: Generat6] Generating migration report...');
+  // Step 5: Generate migration report
+  console.log(`\n[5/${totalSteps}] Generating migration report...`);
   const removedResources = await findRemovedResources(resourcesDir);
   const report = await generateReport(context, compareResults, removedResources);
   context.steps.push('report');
@@ -81,9 +85,9 @@ export async function runMigration(config) {
   // Step 6: Compare terminology bindings
   let terminologyReport = null;
   if (config.skipTerminologyReport) {
-    console.log('\n[6/6] Terminology comparison - SKIPPED (skipTerminologyReport is enabled)');
+    console.log(`\n[6/${totalSteps}] Terminology comparison - SKIPPED (skipTerminologyReport is enabled)`);
   } else {
-    console.log('\n[6/6] Comparing terminology bindings...');
+    console.log(`\n[6/${totalSteps}] Comparing terminology bindings...`);
     try {
       terminologyReport = await runTerminologyComparison(context);
       if (terminologyReport) {
@@ -95,10 +99,26 @@ export async function runMigration(config) {
     }
   }
 
+  let searchParameterReport = null;
+  if (config.skipSearchParameterReport) {
+    console.log(`\n[7/${totalSteps}] SearchParameter report - SKIPPED (skipSearchParameterReport is enabled)`);
+  } else {
+    console.log(`\n[7/${totalSteps}] Analyzing removed search parameters...`);
+    try {
+      searchParameterReport = await runSearchParameterComparison(context);
+      if (searchParameterReport) {
+        context.steps.push('searchParameters');
+      }
+    } catch (error) {
+      console.warn(`  SearchParameter analysis failed: ${error.message}`);
+      console.warn('  Continuing without search parameter report...');
+    }
+  }
+
   let exportZipPath = null;
   if (config.exportZip) {
     console.log('\nGenerating export ZIP...');
-    exportZipPath = await exportComparisonZip(context, report, terminologyReport);
+    exportZipPath = await exportComparisonZip(context, report, terminologyReport, searchParameterReport);
     context.steps.push('exportZip');
   }
   
@@ -106,6 +126,12 @@ export async function runMigration(config) {
   console.log(`  Report: ${report.path}`);
   console.log(`  Total Score: ${report.score}`);
   console.log(`  Findings: ${report.findingsCount}`);
+  if (terminologyReport?.path) {
+    console.log(`  Terminology report: ${terminologyReport.path}`);
+  }
+  if (searchParameterReport?.path) {
+    console.log(`  SearchParameter report: ${searchParameterReport.path}`);
+  }
   if (exportZipPath) {
     console.log(`  Export ZIP: ${exportZipPath}`);
   }
@@ -239,6 +265,25 @@ async function runTerminologyComparison(context) {
   return result;
 }
 
+async function runSearchParameterComparison(context) {
+  const { resourcesDir, outputDir, config } = context;
+
+  const options = {
+    debug: config.debug || false,
+  };
+
+  const result = await compareSearchParameters(resourcesDir, outputDir, options);
+
+  if (result) {
+    console.log(`  Removed search parameter matches: ${result.matchCount}`);
+    console.log(`  Affected CapabilityStatements: ${result.affectedCpsCount}`);
+    console.log(`  Markdown report: ${result.path}`);
+    console.log(`  JSON report: ${result.jsonPath}`);
+  }
+
+  return result;
+}
+
 /**
  * Get list of profiles that need to be compared
  */
@@ -341,7 +386,7 @@ async function generateReport(context, compareResults, removedResources = []) {
 /**
  * Create a ZIP export with compare HTML files, report, and run config
  */
-async function exportComparisonZip(context, report, terminologyReport = null) {
+async function exportComparisonZip(context, report, terminologyReport = null, searchParameterReport = null) {
   const { compareDir, outputDir, config } = context;
   const exportFilename = 'diffyr6-publish.zip';
   const exportPath = path.join(outputDir, exportFilename);
@@ -368,22 +413,43 @@ async function exportComparisonZip(context, report, terminologyReport = null) {
     mtime: (await fsp.stat(report.path)).mtime,
   });
 
+  const terminologyReportForZip = await resolveReportForZip(outputDir, 'terminology-report', terminologyReport);
+  const searchParameterReportForZip = await resolveReportForZip(outputDir, 'searchparameter-report', searchParameterReport);
+
   // Add terminology report if available
-  if (terminologyReport && terminologyReport.path) {
-    const termContent = await fsp.readFile(terminologyReport.path);
+  if (terminologyReportForZip?.path) {
+    const termContent = await fsp.readFile(terminologyReportForZip.path);
     entries.push({
-      name: terminologyReport.filename,
+      name: terminologyReportForZip.filename,
       data: termContent,
-      mtime: (await fsp.stat(terminologyReport.path)).mtime,
+      mtime: (await fsp.stat(terminologyReportForZip.path)).mtime,
     });
     
     // Add terminology JSON if available
-    if (terminologyReport.jsonPath) {
-      const termJsonContent = await fsp.readFile(terminologyReport.jsonPath);
+    if (terminologyReportForZip.jsonPath) {
+      const termJsonContent = await fsp.readFile(terminologyReportForZip.jsonPath);
       entries.push({
-        name: terminologyReport.jsonFilename,
+        name: terminologyReportForZip.jsonFilename,
         data: termJsonContent,
-        mtime: (await fsp.stat(terminologyReport.jsonPath)).mtime,
+        mtime: (await fsp.stat(terminologyReportForZip.jsonPath)).mtime,
+      });
+    }
+  }
+
+  if (searchParameterReportForZip?.path) {
+    const searchParamContent = await fsp.readFile(searchParameterReportForZip.path);
+    entries.push({
+      name: searchParameterReportForZip.filename,
+      data: searchParamContent,
+      mtime: (await fsp.stat(searchParameterReportForZip.path)).mtime,
+    });
+
+    if (searchParameterReportForZip.jsonPath) {
+      const searchParamJsonContent = await fsp.readFile(searchParameterReportForZip.jsonPath);
+      entries.push({
+        name: searchParameterReportForZip.jsonFilename,
+        data: searchParamJsonContent,
+        mtime: (await fsp.stat(searchParameterReportForZip.jsonPath)).mtime,
       });
     }
   }
@@ -399,6 +465,57 @@ async function exportComparisonZip(context, report, terminologyReport = null) {
   return exportPath;
 }
 
+async function resolveReportForZip(outputDir, prefix, currentReport = null) {
+  if (currentReport?.path && await fileExists(currentReport.path)) {
+    return currentReport;
+  }
+
+  const latestReport = await findLatestExistingReport(outputDir, prefix);
+  return latestReport;
+}
+
+async function findLatestExistingReport(outputDir, prefix) {
+  const exists = await directoryExists(outputDir);
+  if (!exists) {
+    return null;
+  }
+
+  const entries = await fsp.readdir(outputDir).catch(() => []);
+  const reportFiles = entries.filter(name => new RegExp(`^${escapeRegex(prefix)}-.+\\.(md|json)$`, 'i').test(name));
+  if (reportFiles.length === 0) {
+    return null;
+  }
+
+  const groups = new Map();
+  for (const filename of reportFiles) {
+    const ext = path.extname(filename).toLowerCase();
+    const stem = filename.slice(0, -ext.length);
+    const filePath = path.join(outputDir, filename);
+    const stat = await fsp.stat(filePath).catch(() => null);
+    if (!stat?.isFile()) {
+      continue;
+    }
+
+    const existing = groups.get(stem) || { stem, latestMtimeMs: 0 };
+    existing.latestMtimeMs = Math.max(existing.latestMtimeMs, stat.mtimeMs);
+    if (ext === '.md') {
+      existing.path = filePath;
+      existing.filename = filename;
+    } else if (ext === '.json') {
+      existing.jsonPath = filePath;
+      existing.jsonFilename = filename;
+    }
+    groups.set(stem, existing);
+  }
+
+  const sorted = Array.from(groups.values()).sort((a, b) => b.latestMtimeMs - a.latestMtimeMs);
+  return sorted[0] || null;
+}
+
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
 async function listExportHtmlFiles(compareDir) {
   const exists = await directoryExists(compareDir);
   if (!exists) {