@gefyra/diffyr6-cli 1.0.0

package/src/utils/process.js

@@ -0,0 +1,101 @@
+import { spawn } from 'child_process';
+
+/**
+ * Spawns a process and collects or streams output
+ */
+export function spawnProcess(command, args, cwd, options = {}) {
+  const { rejectOnNonZero = false, stream = false, stdio } = options;
+  return new Promise((resolve, reject) => {
+    const spawnOptions = {
+      cwd,
+      shell: process.platform === 'win32',
+      env: process.env,
+    };
+    if (stdio) {
+      spawnOptions.stdio = stdio;
+    } else if (stream) {
+      spawnOptions.stdio = 'inherit';
+    }
+
+    const child = spawn(command, args, spawnOptions);
+
+    let stdout = '';
+    let stderr = '';
+
+    const collectOutput = !spawnOptions.stdio;
+    if (collectOutput && child.stdout) {
+      child.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+    }
+    if (collectOutput && child.stderr) {
+      child.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+    }
+    child.on('error', (error) => {
+      reject(
+        new Error(`${command} could not be started: ${error.message}`)
+      );
+    });
+    child.on('close', (code) => {
+      const exitCode = code ?? 0;
+      if (rejectOnNonZero && exitCode !== 0) {
+        const msg = collectOutput
+          ? `${command} failed (exit code ${exitCode}). Details:\n${stdout}\n${stderr}`
+          : `${command} failed (exit code ${exitCode}).`;
+        reject(new Error(msg));
+        return;
+      }
+      resolve({ stdout, stderr, exitCode });
+    });
+  });
+}
+
+/**
+ * Creates a simple terminal spinner with configurable frames
+ */
+export function createAnimator(label, options = {}) {
+  const frames =
+    options.frames ||
+    [
+      '🐟     ~~~~~',
+      ' 🐟    ~~~~~',
+      '  🐟   ~~~~~',
+      '   🐟  ~~~~~',
+      '    🐟 ~~~~~',
+      '   🐟  ~~~~~',
+      '  🐟   ~~~~~',
+      ' 🐟    ~~~~~',
+    ];
+  const interval = options.interval || 150;
+  let index = 0;
+  let timer = null;
+
+  function render() {
+    const frame = frames[index];
+    index = (index + 1) % frames.length;
+    const text = `${frame} ${label}`;
+    process.stdout.write(`\r${text}`);
+  }
+
+  return {
+    start() {
+      if (timer) {
+        return;
+      }
+      render();
+      timer = setInterval(render, interval);
+    },
+    stop() {
+      if (!timer) {
+        return;
+      }
+      clearInterval(timer);
+      timer = null;
+      process.stdout.write('\r');
+      const blank = ' '.repeat(process.stdout.columns || 40);
+      process.stdout.write(`${blank}\r`);
+    },
+  };
+}

package/src/utils/removed-resources.js

@@ -0,0 +1,135 @@
+import fsp from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Identifies R4 profiles that are based on resource types removed in R6
+ * @param {string} r4Dir - R4 resources directory
+ * @returns {Promise<Array<{profile: string, resource: string}>>}
+ */
+export async function findRemovedResources(r4Dir) {
+  // Load list of resources removed in R6
+  const removedResourceTypes = await loadRemovedResourceTypes();
+  const removedSet = new Set(removedResourceTypes);
+  
+  // Read R4 profiles
+  const r4Profiles = await readProfileResources(r4Dir);
+  
+  // Filter profiles based on removed resource types
+  const removed = [];
+  for (const { profile, resource } of r4Profiles) {
+    if (removedSet.has(resource)) {
+      removed.push({ profile, resource });
+    }
+  }
+  
+  return removed;
+}
+
+/**
+ * Loads the list of resource types that were removed in R6
+ */
+async function loadRemovedResourceTypes() {
+  const configPath = path.resolve(__dirname, '..', '..', 'config', 'resources-r4-not-in-r6.json');
+  const content = await fsp.readFile(configPath, 'utf8');
+  const data = JSON.parse(content);
+  return data.resources || [];
+}
+
+/**
+ * Reads all StructureDefinition profiles from a directory
+ */
+async function readProfileResources(baseDir) {
+  const resourcesDir = path.join(baseDir, 'fsh-generated', 'resources');
+  const stat = await fsp.stat(resourcesDir).catch(() => null);
+  if (!stat || !stat.isDirectory()) {
+    return [];
+  }
+  
+  const files = await collectJsonFiles(resourcesDir);
+  const results = [];
+  const seen = new Set();
+  
+  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 || data.resourceType !== 'StructureDefinition') {
+      continue;
+    }
+    
+    const resource = resolveProfileResourceType(data);
+    const profile =
+      data.title ||
+      data.name ||
+      data.id ||
+      extractLastSegment(data.url) ||
+      path.basename(filePath, '.json');
+    
+    if (!resource || !profile) {
+      continue;
+    }
+    
+    const key = `${profile}::${resource}`.toLowerCase();
+    if (seen.has(key)) {
+      continue;
+    }
+    
+    seen.add(key);
+    results.push({ profile, resource });
+  }
+  
+  return results;
+}
+
+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 resolveProfileResourceType(data) {
+  if (!data || typeof data !== 'object') {
+    return '';
+  }
+  if (typeof data.type === 'string' && data.type) {
+    return data.type;
+  }
+  if (typeof data.baseDefinition === 'string' && data.baseDefinition) {
+    return extractLastSegment(data.baseDefinition);
+  }
+  return '';
+}
+
+function extractLastSegment(url) {
+  if (!url) {
+    return '';
+  }
+  const hashIndex = url.lastIndexOf('#');
+  const slashIndex = url.lastIndexOf('/');
+  const index = Math.max(hashIndex, slashIndex);
+  return index >= 0 ? url.slice(index + 1) : url;
+}

package/src/utils/sushi-log.js

@@ -0,0 +1,46 @@
+/**
+ * Parses SUSHI log files and returns a list of error entries with file/line information
+ */
+export function parseSushiLog(logContent) {
+  const entries = [];
+  const lines = logContent.split(/\r?\n/);
+  let index = 0;
+
+  while (index < lines.length) {
+    const line = lines[index];
+    const errorMatch = line.match(/^\s*error\s+(.*)$/i);
+    if (!errorMatch) {
+      index += 1;
+      continue;
+    }
+
+    const entry = { message: errorMatch[1], file: null, line: null, endLine: null };
+    index += 1;
+
+    while (index < lines.length) {
+      const detailMatch = lines[index].match(/^\s{2,}(.*)$/);
+      if (!detailMatch) {
+        break;
+      }
+      const detail = detailMatch[1].trim();
+      const fileMatch = detail.match(/^File:\s*(.+)$/i);
+      if (fileMatch) {
+        entry.file = fileMatch[1];
+      }
+      // Parse single line (e.g., "Line: 122") or line range (e.g., "Line: 122 - 124")
+      const lineRangeMatch = detail.match(/^Line:\s*(\d+)\s*-\s*(\d+)$/i);
+      const lineMatch = detail.match(/^Line:\s*(\d+)$/i);
+      if (lineRangeMatch) {
+        entry.line = Number.parseInt(lineRangeMatch[1], 10);
+        entry.endLine = Number.parseInt(lineRangeMatch[2], 10);
+      } else if (lineMatch) {
+        entry.line = Number.parseInt(lineMatch[1], 10);
+      }
+      index += 1;
+    }
+
+    entries.push(entry);
+  }
+
+  return entries;
+}

package/src/utils/validator.js

@@ -0,0 +1,103 @@
+import fsp from 'fs/promises';
+import fs from 'fs';
+import https from 'https';
+import path from 'path';
+import { fileExists } from './fs.js';
+import { createAnimator } from './process.js';
+
+const VALIDATOR_DOWNLOAD_URL = 'https://github.com/hapifhir/org.hl7.fhir.core/releases/download/6.7.10/validator_cli.jar';
+const DEFAULT_VALIDATOR_FILENAME = 'validator_cli.jar';
+
+/**
+ * Ensures the validator JAR exists, downloading it if necessary
+ * @param {string|null} jarPath - Path to validator JAR or null for auto-download
+ * @param {string} workdir - Working directory where to download the JAR
+ * @returns {Promise<string>} Path to the validator JAR
+ */
+export async function ensureValidator(jarPath, workdir) {
+  // If jarPath is explicitly provided, verify it exists
+  if (jarPath) {
+    const resolvedPath = path.isAbsolute(jarPath) ? jarPath : path.resolve(workdir, jarPath);
+    if (await fileExists(resolvedPath)) {
+      return resolvedPath;
+    }
+    throw new Error(`Validator JAR not found at specified path: ${resolvedPath}`);
+  }
+
+  // Auto-download: check default location in workdir
+  const defaultPath = path.resolve(workdir, DEFAULT_VALIDATOR_FILENAME);
+  if (await fileExists(defaultPath)) {
+    console.log(`  Using existing validator: ${defaultPath}`);
+    return defaultPath;
+  }
+
+  // Download validator
+  console.log('  Validator not found, downloading latest version...');
+  await downloadValidator(defaultPath);
+  console.log(`  Downloaded validator to: ${defaultPath}`);
+  return defaultPath;
+}
+
+/**
+ * Downloads the validator JAR from GitHub releases
+ */
+async function downloadValidator(targetPath) {
+  await fsp.mkdir(path.dirname(targetPath), { recursive: true });
+  
+  const animator = createAnimator('Downloading HL7 FHIR Validator...');
+  animator.start();
+  
+  try {
+    await downloadFile(VALIDATOR_DOWNLOAD_URL, targetPath);
+  } finally {
+    animator.stop();
+  }
+}
+
+/**
+ * Downloads a file from a URL with redirect following
+ */
+async function downloadFile(url, targetPath, maxRedirects = 5) {
+  if (maxRedirects <= 0) {
+    throw new Error('Too many redirects while downloading validator');
+  }
+
+  return new Promise((resolve, reject) => {
+    https.get(url, (response) => {
+      // Handle redirects
+      if (response.statusCode === 301 || response.statusCode === 302 || response.statusCode === 307 || response.statusCode === 308) {
+        const redirectUrl = response.headers.location;
+        if (!redirectUrl) {
+          reject(new Error('Redirect without location header'));
+          return;
+        }
+        downloadFile(redirectUrl, targetPath, maxRedirects - 1)
+          .then(resolve)
+          .catch(reject);
+        return;
+      }
+
+      // Handle errors
+      if (response.statusCode !== 200) {
+        reject(new Error(`Failed to download validator: HTTP ${response.statusCode}`));
+        return;
+      }
+
+      // Write to file
+      const fileStream = fs.createWriteStream(targetPath);
+      response.pipe(fileStream);
+
+      fileStream.on('finish', () => {
+        fileStream.close();
+        resolve();
+      });
+
+      fileStream.on('error', (err) => {
+        fsp.unlink(targetPath).catch(() => {});
+        reject(err);
+      });
+    }).on('error', (err) => {
+      reject(new Error(`Network error while downloading validator: ${err.message}`));
+    });
+  });
+}