fhirsmith 0.3.0

package/tx/importers/tx-import-base.js

@@ -0,0 +1,351 @@
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const cliProgress = require('cli-progress');
+const fs = require('fs');
+const path = require('path');
+const { getConfigManager } = require('./tx-import-settings');
+
+/**
+ * Base class for terminology import modules
+ * All terminology importers should extend this class
+ */
+class BaseTerminologyModule {
+  constructor() {
+    this.progressBar = null;
+    this.configManager = getConfigManager();
+  }
+
+  // Abstract methods - must be implemented by subclasses
+  getName() {
+    throw new Error('getName() must be implemented by subclass');
+  }
+
+  getDescription() {
+    throw new Error('getDescription() must be implemented by subclass');
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  registerCommands(terminologyCommand, globalOptions) {
+    throw new Error('registerCommands() must be implemented by subclass');
+  }
+
+  // Optional methods - can be overridden by subclasses
+  getSupportedFormats() {
+    return ['txt', 'csv', 'tsv'];
+  }
+
+  getEstimatedDuration() {
+    return 'varies';
+  }
+
+  getDefaultConfig() {
+    return {
+      verbose: true,
+      overwrite: false,
+      createIndexes: true
+    };
+  }
+
+  // Common utility methods available to all modules
+  async gatherCommonConfig(options = {}) {
+    const terminology = this.getName();
+
+    // Get intelligent defaults based on previous usage
+    const smartDefaults = this.configManager.generateDefaults(terminology);
+    const recentSources = this.configManager.getRecentSources(terminology, 3);
+
+    const questions = [];
+
+    // Source file/directory
+    if (!options.source) {
+      // If we have recent sources, offer them as choices
+      if (recentSources.length > 0) {
+        questions.push({
+          type: 'list',
+          name: 'sourceChoice',
+          message: `Select source for ${terminology}:`,
+          choices: [
+            ...recentSources.map(src => ({
+              name: `${src} ${src === smartDefaults.source ? '(last used)' : ''}`.trim(),
+              value: src
+            })),
+            { name: 'Enter new path...', value: 'NEW_PATH' }
+          ]
+        });
+
+        // Follow up question for new path
+        questions.push({
+          type: 'input',
+          name: 'newSource',
+          message: `Enter new source path for ${terminology}:`,
+          when: (answers) => answers.sourceChoice === 'NEW_PATH',
+          validate: (input) => {
+            if (!input) return 'Source is required';
+            if (!fs.existsSync(input)) return 'Source path does not exist';
+            return true;
+          },
+          filter: (input) => path.resolve(input)
+        });
+      } else {
+        // No recent sources, just ask for input directly
+        questions.push({
+          type: 'input',
+          name: 'source',
+          message: `Source file/directory for ${terminology}:`,
+          default: smartDefaults.source,
+          validate: (input) => {
+            if (!input) return 'Source is required';
+            if (!fs.existsSync(input)) return 'Source path does not exist';
+            return true;
+          },
+          filter: (input) => path.resolve(input)
+        });
+      }
+    }
+
+    // Destination database
+    if (!options.dest) {
+      questions.push({
+        type: 'input',
+        name: 'dest',
+        message: 'Destination database path:',
+        default: smartDefaults.dest || `./data/${terminology}.db`,
+        validate: (input) => {
+          if (!input) return 'Destination path is required';
+          const dir = path.dirname(input);
+          if (!fs.existsSync(dir)) {
+            return `Directory does not exist: ${dir}`;
+          }
+          return true;
+        },
+        filter: (input) => path.resolve(input)
+      });
+    }
+
+    // Overwrite confirmation
+    questions.push({
+      type: 'confirm',
+      name: 'overwrite',
+      message: 'Overwrite existing database if it exists?',
+      default: smartDefaults.overwrite !== undefined ? smartDefaults.overwrite : false,
+      when: (answers) => {
+        const destPath = options.dest || answers.dest;
+        return fs.existsSync(destPath);
+      }
+    });
+
+    questions.push({
+      type: 'confirm',
+      name: 'verbose',
+      message: 'Show verbose progress output?',
+      default: smartDefaults.verbose !== undefined ? smartDefaults.verbose : true
+    });
+
+    const answers = await inquirer.prompt(questions);
+
+    // Handle source selection logic
+    let finalSource = options.source;
+    if (!finalSource) {
+      if (answers.sourceChoice === 'NEW_PATH') {
+        finalSource = answers.newSource;
+      } else if (answers.sourceChoice) {
+        finalSource = answers.sourceChoice;
+      } else {
+        finalSource = answers.source;
+      }
+    }
+
+    const finalConfig = {
+      ...this.getDefaultConfig(),
+      ...smartDefaults,
+      ...options,
+      ...answers,
+      source: finalSource
+    };
+
+    return finalConfig;
+  }
+
+  async confirmImport(config) {
+    console.log(chalk.cyan(`\n📋 ${this.getName()} Import Configuration:`));
+    console.log(`  Source: ${chalk.white(config.source)}`);
+    console.log(`  Destination: ${chalk.white(config.dest)}`);
+    console.log(`  Version: ${chalk.white(config.version || 'Not specified')}`);
+    console.log(`  Overwrite: ${chalk.white(config.overwrite ? 'Yes' : 'No')}`);
+
+    if (config.estimatedDuration) {
+      console.log(`  Estimated Duration: ${chalk.white(config.estimatedDuration)}`);
+    }
+
+    const { confirmed } = await inquirer.prompt({
+      type: 'confirm',
+      name: 'confirmed',
+      message: 'Proceed with import?',
+      default: true
+    });
+
+    return confirmed;
+  }
+
+  createProgressBar(format = null) {
+    const defaultFormat = chalk.cyan('Progress') + ' |{bar}| {percentage}% | {value}/{total} | ETA: {eta}s';
+
+    this.progressBar = new cliProgress.SingleBar({
+      format: format || defaultFormat,
+      barCompleteChar: '█',
+      barIncompleteChar: '░',
+      hideCursor: true
+    });
+
+    return this.progressBar;
+  }
+
+  updateProgress(current, total = null) {
+    if (this.progressBar) {
+      if (total !== null) {
+        this.progressBar.start(total, current);
+      } else {
+        this.progressBar.update(current);
+      }
+    }
+  }
+
+  stopProgress() {
+    if (this.progressBar) {
+      this.progressBar.stop();
+      this.progressBar = null;
+    }
+  }
+
+  logInfo(message) {
+    console.log(chalk.blue('ℹ'), message);
+  }
+
+  logSuccess(message) {
+    console.log(chalk.green('✓'), message);
+  }
+
+  logWarning(message) {
+    console.log(chalk.yellow('⚠'), message);
+  }
+
+  logError(message) {
+    console.log(chalk.red('✗'), message);
+  }
+
+  async validatePrerequisites(config) {
+    // Base validation - can be extended by subclasses
+    const checks = [
+      {
+        name: 'Source exists',
+        check: () => fs.existsSync(config.source)
+      },
+      {
+        name: 'Destination directory writable',
+        check: () => {
+          const dir = path.dirname(config.dest);
+          return fs.existsSync(dir);
+        }
+      }
+    ];
+
+    let allPassed = true;
+
+    for (const { name, check } of checks) {
+      try {
+        const passed = await check();
+        if (passed) {
+          this.logSuccess(name);
+        } else {
+          this.logError(name);
+          allPassed = false;
+        }
+      } catch (error) {
+        this.logError(`${name}: ${error.message}`);
+        allPassed = false;
+      }
+    }
+
+    return allPassed;
+  }
+
+  // Helper method for batch processing with progress updates
+  async processBatch(items, batchSize, processor, progressMessage = 'Processing') {
+    const total = items.length;
+    let processed = 0;
+
+    this.createProgressBar(
+      chalk.cyan(progressMessage) + ' |{bar}| {percentage}% | {value}/{total} items'
+    );
+    this.updateProgress(0, total);
+
+    for (let i = 0; i < total; i += batchSize) {
+      const batch = items.slice(i, i + batchSize);
+      await processor(batch);
+      processed += batch.length;
+      this.updateProgress(processed);
+    }
+
+    this.stopProgress();
+    return processed;
+  }
+
+  // Abstract method for actual import logic
+  // eslint-disable-next-line no-unused-vars
+  async executeImport(config) {
+    throw new Error('executeImport() must be implemented by subclass');
+  }
+
+  // Common import workflow
+  async runImport(config) {
+    try {
+      console.log(chalk.blue.bold(`🏥 Starting ${this.getName()} Import...\n`));
+
+      // Pre-flight checks
+      this.logInfo('Running pre-flight checks...');
+      const prerequisitesPassed = await this.validatePrerequisites(config);
+
+      if (!prerequisitesPassed) {
+        throw new Error('Pre-flight checks failed');
+      }
+
+      // Execute the import
+      await this.executeImport(config);
+
+      // Remember successful configuration for future use
+      this.rememberSuccessfulConfig(config);
+
+      this.logSuccess(`${this.getName()} import completed successfully!`);
+
+    } catch (error) {
+      this.stopProgress(); // Ensure progress bar is cleaned up
+      this.logError(`${this.getName()} import failed: ${error.message}`);
+      if (config.verbose) {
+        console.error(error.stack);
+      }
+      process.exit(1);
+    }
+  }
+
+  // Remember successful configuration
+  rememberSuccessfulConfig(config) {
+    try {
+      const terminology = this.getName();
+
+      // Remember the source path in recent sources
+      if (config.source) {
+        this.configManager.rememberSource(terminology, config.source);
+      }
+
+      // Remember the full configuration
+      this.configManager.rememberConfig(terminology, config);
+
+      this.logInfo('Configuration saved for future use');
+    } catch (error) {
+      // Don't fail the import if we can't save config
+      this.logWarning(`Could not save configuration: ${error.message}`);
+    }
+  }
+}
+
+module.exports = { BaseTerminologyModule };

package/tx/importers/tx-import-settings.js

@@ -0,0 +1,310 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Manages persistent configuration for terminology import tools
+ * Remembers previous inputs and uses them as defaults
+ */
+class ConfigManager {
+  constructor() {
+    this.configDir = path.join(os.homedir(), '.tx-import');
+    this.configFile = path.join(this.configDir, 'config.json');
+    this.historyFile = path.join(this.configDir, 'history.json');
+    this.config = {};
+    this.history = {};
+
+    this.ensureConfigDir();
+    this.loadConfig();
+    this.loadHistory();
+  }
+
+  ensureConfigDir() {
+    if (!fs.existsSync(this.configDir)) {
+      fs.mkdirSync(this.configDir, { recursive: true });
+    }
+  }
+
+  loadConfig() {
+    try {
+      if (fs.existsSync(this.configFile)) {
+        this.config = JSON.parse(fs.readFileSync(this.configFile, 'utf8'));
+      }
+    } catch (error) {
+      console.warn(`Warning: Could not load config: ${error.message}`);
+      this.config = {};
+    }
+  }
+
+  loadHistory() {
+    try {
+      if (fs.existsSync(this.historyFile)) {
+        this.history = JSON.parse(fs.readFileSync(this.historyFile, 'utf8'));
+      }
+    } catch (error) {
+      console.warn(`Warning: Could not load history: ${error.message}`);
+      this.history = {};
+    }
+  }
+
+  saveConfig() {
+    try {
+      fs.writeFileSync(this.configFile, JSON.stringify(this.config, null, 2));
+    } catch (error) {
+      console.warn(`Warning: Could not save config: ${error.message}`);
+    }
+  }
+
+  saveHistory() {
+    try {
+      fs.writeFileSync(this.historyFile, JSON.stringify(this.history, null, 2));
+    } catch (error) {
+      console.warn(`Warning: Could not save history: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get previous value for a specific terminology and field
+   * @param {string} terminology - e.g., 'unii', 'loinc'
+   * @param {string} field - e.g., 'source', 'dest', 'version'
+   * @returns {string|null} Previous value or null if not found
+   */
+  getPreviousValue(terminology, field) {
+    return this.history[terminology]?.[field] || null;
+  }
+
+  /**
+   * Get all previous values for a terminology
+   * @param {string} terminology
+   * @returns {object} Object with all previous values
+   */
+  getPreviousConfig(terminology) {
+    return this.history[terminology] || {};
+  }
+
+  /**
+   * Remember a successful configuration
+   * @param {string} terminology
+   * @param {object} config
+   */
+  rememberConfig(terminology, config) {
+    if (!this.history[terminology]) {
+      this.history[terminology] = {};
+    }
+
+    // Store important fields
+    const fieldsToRemember = ['source', 'dest', 'version', 'languages', 'overwrite', 'verbose'];
+
+    fieldsToRemember.forEach(field => {
+      if (config[field] !== undefined) {
+        this.history[terminology][field] = config[field];
+      }
+    });
+
+    // Store timestamp of last use
+    this.history[terminology].lastUsed = new Date().toISOString();
+
+    this.saveHistory();
+  }
+
+  /**
+   * Get recent source directories for a terminology
+   * @param {string} terminology
+   * @param {number} limit
+   * @returns {string[]} Array of recent source paths
+   */
+  getRecentSources(terminology, limit = 5) {
+    const termHistory = this.history[terminology];
+    if (!termHistory || !termHistory.recentSources) {
+      return [];
+    }
+
+    return termHistory.recentSources.slice(0, limit);
+  }
+
+  /**
+   * Remember a source path
+   * @param {string} terminology
+   * @param {string} sourcePath
+   */
+  rememberSource(terminology, sourcePath) {
+    if (!this.history[terminology]) {
+      this.history[terminology] = {};
+    }
+
+    if (!this.history[terminology].recentSources) {
+      this.history[terminology].recentSources = [];
+    }
+
+    const sources = this.history[terminology].recentSources;
+
+    // Remove if already exists
+    const index = sources.indexOf(sourcePath);
+    if (index > -1) {
+      sources.splice(index, 1);
+    }
+
+    // Add to front
+    sources.unshift(sourcePath);
+
+    // Keep only last 10
+    this.history[terminology].recentSources = sources.slice(0, 10);
+
+    this.saveHistory();
+  }
+
+  /**
+   * Clear history for a specific terminology
+   * @param {string} terminology
+   */
+  clearHistory(terminology) {
+    if (this.history[terminology]) {
+      delete this.history[terminology];
+      this.saveHistory();
+    }
+  }
+
+  /**
+   * Clear all history
+   */
+  clearAllHistory() {
+    this.history = {};
+    this.saveHistory();
+  }
+
+  /**
+   * Get global preferences
+   * @param {string} key
+   * @param {any} defaultValue
+   * @returns {any}
+   */
+  getPreference(key, defaultValue = null) {
+    return this.config[key] !== undefined ? this.config[key] : defaultValue;
+  }
+
+  /**
+   * Set global preference
+   * @param {string} key
+   * @param {any} value
+   */
+  setPreference(key, value) {
+    this.config[key] = value;
+    this.saveConfig();
+  }
+
+  /**
+   * Generate intelligent defaults based on previous usage
+   * @param {string} terminology
+   * @returns {object} Suggested defaults
+   */
+  generateDefaults(terminology) {
+    const previous = this.getPreviousConfig(terminology);
+    const defaults = {};
+
+    // Default source - use most recent
+    if (previous.source) {
+      defaults.source = previous.source;
+    }
+
+    // Default destination - increment version or use pattern
+    if (previous.dest) {
+      defaults.dest = this.suggestNextDestination(previous.dest, terminology);
+    } else {
+      defaults.dest = `./data/${terminology}.db`;
+    }
+
+    // Default version - increment or use date pattern
+    if (previous.version) {
+      defaults.version = this.suggestNextVersion(previous.version, terminology);
+    } else {
+      const date = new Date().toISOString().split('T')[0];
+      defaults.version = `${terminology.toUpperCase()}-${date}`;
+    }
+
+    // Inherit boolean preferences
+    if (previous.verbose !== undefined) defaults.verbose = previous.verbose;
+    if (previous.overwrite !== undefined) defaults.overwrite = previous.overwrite;
+    if (previous.languages !== undefined) defaults.languages = previous.languages;
+
+    return defaults;
+  }
+
+  suggestNextDestination(previousDest) {
+    // If previous dest was versioned, suggest incrementing
+    const versionMatch = previousDest.match(/-v(\d+)\.db$/);
+    if (versionMatch) {
+      const nextVersion = parseInt(versionMatch[1]) + 1;
+      return previousDest.replace(/-v\d+\.db$/, `-v${nextVersion}.db`);
+    }
+
+    // If it had a date, suggest today's date
+    const dateMatch = previousDest.match(/-(\d{4}-\d{2}-\d{2})\.db$/);
+    if (dateMatch) {
+      const today = new Date().toISOString().split('T')[0];
+      return previousDest.replace(/-\d{4}-\d{2}-\d{2}\.db$/, `-${today}.db`);
+    }
+
+    // Otherwise, just return the same path
+    return previousDest;
+  }
+
+  suggestNextVersion(previousVersion) {
+    // If version has a date, suggest today's date
+    const dateMatch = previousVersion.match(/-(\d{4}-\d{2}-\d{2})$/);
+    if (dateMatch) {
+      const today = new Date().toISOString().split('T')[0];
+      return previousVersion.replace(/-\d{4}-\d{2}-\d{2}$/, `-${today}`);
+    }
+
+    // If version has a number, increment it
+    const numberMatch = previousVersion.match(/-(\d+)$/);
+    if (numberMatch) {
+      const nextNumber = parseInt(numberMatch[1]) + 1;
+      return previousVersion.replace(/-\d+$/, `-${nextNumber}`);
+    }
+
+    // Otherwise, add today's date
+    const today = new Date().toISOString().split('T')[0];
+    return `${previousVersion}-${today}`;
+  }
+
+  /**
+   * Export configuration for backup
+   * @returns {object} Complete configuration
+   */
+  exportConfig() {
+    return {
+      config: this.config,
+      history: this.history,
+      exportDate: new Date().toISOString()
+    };
+  }
+
+  /**
+   * Import configuration from backup
+   * @param {object} data
+   */
+  importConfig(data) {
+    if (data.config) {
+      this.config = { ...this.config, ...data.config };
+      this.saveConfig();
+    }
+
+    if (data.history) {
+      this.history = { ...this.history, ...data.history };
+      this.saveHistory();
+    }
+  }
+}
+
+// Singleton instance
+let configManagerInstance = null;
+
+function getConfigManager() {
+  if (!configManagerInstance) {
+    configManagerInstance = new ConfigManager();
+  }
+  return configManagerInstance;
+}
+
+module.exports = { ConfigManager, getConfigManager };