unitsdb 2.1.1 → 2.2.1

data/lib/unitsdb/commands/check_si/si_updater.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Unitsdb
+  module Commands
+    module CheckSi
+      # Updater for SI references in YAML
+      module SiUpdater
+        SI_AUTHORITY = "si-digital-framework"
+
+        module_function
+
+        # Update references in YAML file (TTL → DB direction)
+        def update_references(entity_type, missing_matches, db_entities,
+  output_file, include_potential = false)
+          # Use the database objects to access the data directly
+          original_yaml_file = db_entities.first.send(:yaml_file) if db_entities&.first.respond_to?(
+            :yaml_file, true
+          )
+
+          # If we can't get the path from the database object, use the output file path as a fallback
+          if original_yaml_file.nil? || !File.exist?(original_yaml_file)
+            puts "Warning: Could not determine original YAML file path. Using output file as template."
+            original_yaml_file = output_file
+
+            # Create an empty template if output file doesn't exist
+            unless File.exist?(original_yaml_file)
+              FileUtils.mkdir_p(File.dirname(original_yaml_file))
+              File.write(original_yaml_file, { entity_type => [] }.to_yaml)
+            end
+          end
+
+          # Load the original YAML file
+          yaml_content = File.read(original_yaml_file)
+          output_data = YAML.safe_load(yaml_content)
+
+          # Group by entity ID to avoid duplicates
+          grouped_matches = missing_matches.group_by do |match|
+            match[:entity_id]
+          end
+
+          # Process each entity that needs updating
+          grouped_matches.each do |entity_id, matches|
+            # Filter matches based on include_potential parameter
+            filtered_matches = matches.select do |match|
+              # Check if it's an exact match or if we're including potential matches
+              match_details = match[:match_details]
+              if match_details&.dig(:exact) == false || %w[symbol_match
+                                                           partial_match].include?(match_details&.dig(:match_desc) || "")
+                include_potential
+              else
+                true
+              end
+            end
+
+            # Skip if no matches after filtering
+            next if filtered_matches.empty?
+
+            # Find the entity in the array under the entity_type key
+            entity_index = output_data[entity_type].find_index do |e|
+              # Find entity with matching identifier
+              e["identifiers"]&.any? { |id| id["id"] == entity_id }
+            end
+
+            next unless entity_index
+
+            # Get the entity
+            entity = output_data[entity_type][entity_index]
+
+            # Initialize references array if it doesn't exist
+            entity["references"] ||= []
+
+            # Add new references
+            filtered_matches.each do |match|
+              # If this match has multiple SI references, add them all
+              if match[:multiple_si]
+                match[:multiple_si].each do |si_data|
+                  # Check if reference already exists
+                  next if entity["references"].any? do |ref|
+                    ref["uri"] == si_data[:uri] && ref["authority"] == SI_AUTHORITY
+                  end
+
+                  # Add new reference
+                  entity["references"] << {
+                    "uri" => si_data[:uri],
+                    "type" => "normative",
+                    "authority" => SI_AUTHORITY,
+                  }
+                end
+              else
+                # Check if reference already exists
+                next if entity["references"].any? do |ref|
+                  ref["uri"] == match[:si_uri] && ref["authority"] == SI_AUTHORITY
+                end
+
+                # Add new reference
+                entity["references"] << {
+                  "uri" => match[:si_uri],
+                  "type" => "normative",
+                  "authority" => SI_AUTHORITY,
+                }
+              end
+            end
+          end
+
+          write_yaml_file(output_file, output_data)
+        end
+
+        # Update references in YAML file (DB → TTL direction)
+        def update_db_references(entity_type, missing_refs, output_file,
+  include_potential = false)
+          # Try to get the original YAML file from the first entity
+          first_entity = missing_refs.first&.dig(:db_entity)
+          original_yaml_file = first_entity.send(:yaml_file) if first_entity.respond_to?(
+            :yaml_file, true
+          )
+
+          # If we can't get the path from the database object, use the output file path as a fallback
+          if original_yaml_file.nil? || !File.exist?(original_yaml_file)
+            puts "Warning: Could not determine original YAML file path. Using output file as template."
+            original_yaml_file = output_file
+
+            # Create an empty template if output file doesn't exist
+            unless File.exist?(original_yaml_file)
+              FileUtils.mkdir_p(File.dirname(original_yaml_file))
+              File.write(original_yaml_file, { entity_type => [] }.to_yaml)
+            end
+          end
+
+          # Load the original YAML file
+          yaml_content = File.read(original_yaml_file)
+          output_data = YAML.safe_load(yaml_content)
+
+          # Group by entity ID to avoid duplicates
+          missing_refs_by_id = {}
+
+          missing_refs.each do |match|
+            entity_id = match[:entity_id] || match[:db_entity].short
+            ttl_entities = match[:ttl_entities]
+            match_types = match[:match_types] || {}
+
+            # Filter TTL entities based on include_potential parameter
+            filtered_ttl_entities = ttl_entities.select do |ttl_entity|
+              # Check if it's an exact match or if we're including potential matches
+              match_type = match_types[ttl_entity[:uri]] || "Exact match" # Default to exact match
+              match_pair_key = "#{entity_id}:#{ttl_entity[:uri]}"
+              match_details = Unitsdb::Commands::CheckSi::SiMatcher.instance_variable_get(:@match_details)&.dig(match_pair_key)
+
+              if match_details && %w[symbol_match
+                                     partial_match].include?(match_details[:match_desc])
+                include_potential
+              else
+                match_type == "Exact match" || include_potential
+              end
+            end
+
+            # Skip if no entities after filtering
+            next if filtered_ttl_entities.empty?
+
+            missing_refs_by_id[entity_id] ||= []
+
+            # Add filtered matching TTL entities for this DB entity
+            filtered_ttl_entities.each do |ttl_entity|
+              missing_refs_by_id[entity_id] << {
+                uri: ttl_entity[:uri],
+                type: "normative",
+                authority: SI_AUTHORITY,
+              }
+            end
+          end
+
+          # Update the YAML content
+          output_data[entity_type].each do |entity_yaml|
+            # Find entity by ID or short
+            entity_id = if entity_yaml["identifiers"]
+                          begin
+                            entity_yaml["identifiers"].first["id"]
+                          rescue StandardError
+                            nil
+                          end
+                        elsif entity_yaml["id"]
+                          entity_yaml["id"]
+                        end
+
+            next unless entity_id && missing_refs_by_id.key?(entity_id)
+
+            # Add references
+            entity_yaml["references"] ||= []
+
+            missing_refs_by_id[entity_id].each do |ref|
+              # Check if this reference already exists
+              next if entity_yaml["references"].any? do |existing_ref|
+                existing_ref["uri"] == ref[:uri] &&
+                  existing_ref["authority"] == ref[:authority]
+              end
+
+              # Add the reference
+              entity_yaml["references"] << {
+                "uri" => ref[:uri],
+                "type" => ref[:type],
+                "authority" => ref[:authority],
+              }
+            end
+          end
+
+          write_yaml_file(output_file, output_data)
+        end
+
+        # Helper to write YAML file
+        def write_yaml_file(output_file, output_data)
+          # Ensure the output directory exists
+          output_dir = File.dirname(output_file)
+          FileUtils.mkdir_p(output_dir)
+
+          # Write to YAML file with proper formatting
+          yaml_content = output_data.to_yaml
+
+          # Preserve existing schema header or add default one
+          yaml_content = preserve_schema_header(output_file, yaml_content)
+
+          File.write(output_file, yaml_content)
+        end
+
+        # Preserve existing schema header or add default one
+        def preserve_schema_header(original_file, yaml_content)
+          schema_header = nil
+
+          # Extract existing schema header if file exists
+          if File.exist?(original_file)
+            original_content = File.read(original_file)
+            if (match = original_content.match(/^# yaml-language-server: \$schema=.+$/))
+              schema_header = match[0]
+            end
+          end
+
+          # Remove any existing schema header from new content to avoid duplication
+          yaml_content = yaml_content.gsub(
+            /^# yaml-language-server: \$schema=.+$\n/, ""
+          )
+
+          # Add preserved or default schema header
+          if schema_header
+            "#{schema_header}\n#{yaml_content}"
+          else
+            entity_type = File.basename(original_file, ".yaml")
+            "# yaml-language-server: $schema=schemas/#{entity_type}-schema.yaml\n#{yaml_content}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/unitsdb/commands/check_si.rb

@@ -1,16 +1,15 @@
 # frozen_string_literal: true
 
-require_relative "base"
-require_relative "../database"
-require_relative "../errors"
-require_relative "si_ttl_parser"
-require_relative "si_formatter"
-require_relative "si_matcher"
-require_relative "si_updater"
-
 module Unitsdb
   module Commands
-    class CheckSi < Base
+    module CheckSi
+      autoload :SiTtlParser, "unitsdb/commands/check_si/si_ttl_parser"
+      autoload :SiMatcher, "unitsdb/commands/check_si/si_matcher"
+      autoload :SiFormatter, "unitsdb/commands/check_si/si_formatter"
+      autoload :SiUpdater, "unitsdb/commands/check_si/si_updater"
+    end
+
+    class CheckSiCommand < Base
       # Constants
       ENTITY_TYPES = %w[units quantities prefixes].freeze
 
@@ -32,91 +31,111 @@ module Unitsdb
         @db = Unitsdb::Database.from_db(database_path)
 
         puts "Using TTL directory: #{ttl_dir}"
-        puts "Include potential matches: #{include_potential ? "Yes" : "No"}"
+        puts "Include potential matches: #{include_potential ? 'Yes' : 'No'}"
 
         # Parse TTL files
-        graph = SiTtlParser.parse_ttl_files(ttl_dir)
+        graph = ::Unitsdb::Commands::CheckSi::SiTtlParser.parse_ttl_files(ttl_dir)
 
         # Process entity types
-        process_entities(entity_type, graph, direction, output_dir, include_potential)
+        process_entities(entity_type, graph, direction, output_dir,
+                         include_potential)
       end
 
       private
 
       # Process all entity types or a specific one
-      def process_entities(entity_type, graph, direction, output_dir, include_potential)
+      def process_entities(entity_type, graph, direction, output_dir,
+include_potential)
         if entity_type && ENTITY_TYPES.include?(entity_type)
-          process_entity_type(entity_type, graph, direction, output_dir, include_potential)
+          process_entity_type(entity_type, graph, direction, output_dir,
+                              include_potential)
         else
           ENTITY_TYPES.each do |type|
-            process_entity_type(type, graph, direction, output_dir, include_potential)
+            process_entity_type(type, graph, direction, output_dir,
+                                include_potential)
           end
         end
       end
 
       # Process a specific entity type
-      def process_entity_type(entity_type, graph, direction, output_dir, include_potential = false)
+      def process_entity_type(entity_type, graph, direction, output_dir,
+include_potential = false)
         puts "\n========== Processing #{entity_type.upcase} References ==========\n"
 
         db_entities = @db.send(entity_type)
-        ttl_entities = SiTtlParser.extract_entities_from_ttl(entity_type, graph)
+        ttl_entities = ::Unitsdb::Commands::CheckSi::SiTtlParser.extract_entities_from_ttl(
+          entity_type, graph
+        )
 
         puts "Found #{ttl_entities.size} #{entity_type} in SI digital framework"
         puts "Found #{db_entities.size} #{entity_type} in database"
 
-        check_from_si(entity_type, ttl_entities, db_entities, output_dir, include_potential) if %w[from_si
-                                                                                                   both].include?(direction)
+        if %w[from_si
+              both].include?(direction)
+          check_from_si(entity_type, ttl_entities, db_entities, output_dir,
+                        include_potential)
+        end
 
         return unless %w[to_si both].include?(direction)
 
-        check_to_si(entity_type, ttl_entities, db_entities, output_dir, include_potential)
+        check_to_si(entity_type, ttl_entities, db_entities, output_dir,
+                    include_potential)
       end
 
       # Validation helpers
       def validate_parameters(direction, ttl_dir)
         unless %w[to_si from_si both].include?(direction)
-          puts "Invalid direction: #{direction}. Must be one of: to_si, from_si, both"
-          exit(1)
+          raise Unitsdb::Errors::InvalidParameterError,
+                "Invalid direction '#{direction}': must be 'to_si', 'from_si', or 'both'"
         end
 
         return if Dir.exist?(ttl_dir)
 
-        puts "TTL directory not found: #{ttl_dir}"
-        exit(1)
+        raise Unitsdb::Errors::FileNotFoundError,
+              "TTL directory not found: #{ttl_dir}"
       end
 
       # Direction handler: TTL → DB
-      def check_from_si(entity_type, ttl_entities, db_entities, output_dir, include_potential = false)
-        SiFormatter.print_direction_header("SI → UnitsDB")
+      def check_from_si(entity_type, ttl_entities, db_entities, output_dir,
+include_potential = false)
+        ::Unitsdb::Commands::CheckSi::SiFormatter.print_direction_header("SI → UnitsDB")
 
-        matches, missing_matches, unmatched_ttl = SiMatcher.match_ttl_to_db(entity_type, ttl_entities, db_entities)
+        matches, missing_matches, unmatched_ttl = ::Unitsdb::Commands::CheckSi::SiMatcher.match_ttl_to_db(
+          entity_type, ttl_entities, db_entities
+        )
 
         # Print results
-        SiFormatter.display_si_results(entity_type, matches, missing_matches, unmatched_ttl)
+        ::Unitsdb::Commands::CheckSi::SiFormatter.display_si_results(entity_type, matches, missing_matches,
+                                                                     unmatched_ttl)
 
         # Update references if needed
         return unless output_dir && !missing_matches.empty?
 
         output_file = File.join(output_dir, "#{entity_type}.yaml")
-        SiUpdater.update_references(entity_type, missing_matches, db_entities, output_file, include_potential,
-                                    database_path)
+        ::Unitsdb::Commands::CheckSi::SiUpdater.update_references(entity_type, missing_matches, db_entities, output_file, include_potential,
+                                                                  database_path)
         puts "\nUpdated references written to #{output_file}"
       end
 
       # Direction handler: DB → TTL
-      def check_to_si(entity_type, ttl_entities, db_entities, output_dir, include_potential = false)
-        SiFormatter.print_direction_header("UnitsDB → SI")
+      def check_to_si(entity_type, ttl_entities, db_entities, output_dir,
+include_potential = false)
+        ::Unitsdb::Commands::CheckSi::SiFormatter.print_direction_header("UnitsDB → SI")
 
-        matches, missing_refs, unmatched_db = SiMatcher.match_db_to_ttl(entity_type, ttl_entities, db_entities)
+        matches, missing_refs, unmatched_db = ::Unitsdb::Commands::CheckSi::SiMatcher.match_db_to_ttl(
+          entity_type, ttl_entities, db_entities
+        )
 
         # Print results
-        SiFormatter.display_db_results(entity_type, matches, missing_refs, unmatched_db)
+        ::Unitsdb::Commands::CheckSi::SiFormatter.display_db_results(entity_type, matches, missing_refs,
+                                                                     unmatched_db)
 
         # Update references if needed
         return unless output_dir && !missing_refs.empty?
 
         output_file = File.join(output_dir, "#{entity_type}.yaml")
-        SiUpdater.update_db_references(entity_type, missing_refs, output_file, include_potential, @options[:database])
+        ::Unitsdb::Commands::CheckSi::SiUpdater.update_db_references(entity_type, missing_refs, output_file,
+                                                                     include_potential, @options[:database])
         puts "\nUpdated references written to #{output_file}"
       end
     end

data/lib/unitsdb/commands/get.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "base"
 require "json"
-require_relative "../errors"
 
 module Unitsdb
   module Commands
@@ -29,19 +27,18 @@ module Unitsdb
               puts entity.send("to_#{format.downcase}")
               return
             rescue NoMethodError
-              puts "Error: Unable to convert entity to #{format} format"
-              exit(1)
+              raise Unitsdb::Errors::InvalidFormatError,
+                    "Unable to convert entity to #{format.upcase} format: output format not supported for this entity type"
             end
           end
 
           # Default text output
           print_entity_details(entity)
         rescue Unitsdb::Errors::DatabaseError => e
-          puts "Error: #{e.message}"
-          exit(1)
+          raise Unitsdb::Errors::DatabaseLoadError,
+                "Failed to load database: #{e.message}"
         rescue StandardError => e
-          puts "Error searching database: #{e.message}"
-          exit(1)
+          raise Unitsdb::Errors::CLIRuntimeError, "Search failed: #{e.message}"
         end
       end
 
@@ -65,7 +62,7 @@ module Unitsdb
         if entity.identifiers&.any?
           puts "  - Identifiers:"
           entity.identifiers.each do |id|
-            puts "      - #{id.id} (Type: #{id.type || "N/A"})"
+            puts "      - #{id.id} (Type: #{id.type || 'N/A'})"
           end
         else
           puts "  - Identifiers: None"
@@ -75,7 +72,11 @@ module Unitsdb
         case entity
         when Unitsdb::Unit
           puts "  - Symbols:" if entity.respond_to?(:symbols) && entity.symbols&.any?
-          entity.symbols.each { |s| puts "      - #{s}" } if entity.respond_to?(:symbols) && entity.symbols&.any?
+          if entity.respond_to?(:symbols) && entity.symbols&.any?
+            entity.symbols.each do |s|
+              puts "      - #{s}"
+            end
+          end
 
           puts "  - Definition: #{entity.definition}" if entity.respond_to?(:definition) && entity.definition
 

data/lib/unitsdb/commands/normalize.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "base"
 require "yaml"
 
 module Unitsdb
@@ -8,8 +7,8 @@ module Unitsdb
     class Normalize < Base
       def run(input = nil, output = nil)
         unless @options[:all] || (input && output)
-          puts "Error: INPUT and OUTPUT are required when not using --all"
-          exit(1)
+          raise Unitsdb::Errors::InvalidParameterError,
+                "INPUT and OUTPUT files are required unless --all flag is specified"
         end
 
         if @options[:all]
@@ -32,8 +31,18 @@ module Unitsdb
       private
 
       def normalize_file(input, output)
+        # Read the original file content to check for schema comment
+        file_content = File.read(input)
+
+        # Check if the first line is a yaml-language-server schema comment
+        schema_comment = nil
+        lines = file_content.lines
+        if lines.first&.start_with?("# yaml-language-server:")
+          schema_comment = lines.first.chomp
+        end
+
         # Load the original YAML to work with
-        yaml = YAML.safe_load(File.read(input))
+        yaml = YAML.safe_load(file_content)
 
         # For schema 2.0.0, we need to handle the schema_version and the main collection key
         if yaml.key?("schema_version") && yaml["schema_version"] == "2.0.0"
@@ -47,7 +56,8 @@ module Unitsdb
             when "nist", "unitsml"
               # Sort by ID (nist or unitsml)
               id_type = @options[:sort]
-              yaml[collection_key] = sort_by_id_type(yaml[collection_key], id_type)
+              yaml[collection_key] =
+                sort_by_id_type(yaml[collection_key], id_type)
             else # default to "short"
               # Use the existing sort_yaml_keys method for default sorting
               yaml[collection_key] = Unitsdb::Utils.sort_yaml_keys(yaml[collection_key])
@@ -58,8 +68,12 @@ module Unitsdb
           yaml = Unitsdb::Utils.sort_yaml_keys(yaml)
         end
 
-        # Write the normalized output
-        File.write(output, yaml.to_yaml)
+        # Write the normalized output, preserving schema comment if present
+        output_content = yaml.to_yaml
+        if schema_comment
+          output_content = "#{schema_comment}\n#{output_content}"
+        end
+        File.write(output, output_content)
       end
 
       # Sort collection items by a specific ID type (nist or unitsml)

data/lib/unitsdb/commands/qudt/check.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Unitsdb
+  module Commands
+    module Qudt
+      class Check < Base
+        # Constants
+        ENTITY_TYPES = %w[units quantities dimensions unit_systems
+                          prefixes].freeze
+
+        def run
+          # Get options
+          entity_type = @options[:entity_type]&.downcase
+          direction = @options[:direction]&.downcase || "both"
+          output_dir = @options[:output_updated_database]
+          include_potential = @options[:include_potential_matches] || false
+          database_path = @options[:database]
+          ttl_dir = @options[:ttl_dir]
+          source_type = ttl_dir ? :file : :url
+
+          # Validate parameters
+          validate_parameters(direction, ttl_dir, source_type)
+
+          # Use the path as-is without expansion
+          puts "Using database directory: #{database_path}"
+
+          @db = Unitsdb::Database.from_db(database_path)
+
+          if source_type == :file
+            puts "Using QUDT TTL directory: #{ttl_dir}"
+          else
+            puts "Downloading QUDT vocabularies from online sources"
+          end
+          puts "Include potential matches: #{include_potential ? 'Yes' : 'No'}"
+
+          # Parse QUDT vocabularies
+          qudt_data = TtlParser.parse_qudt_vocabularies(
+            source_type: source_type, ttl_dir: ttl_dir,
+          )
+
+          # Process entity types
+          process_entities(entity_type, qudt_data, direction, output_dir,
+                           include_potential)
+        end
+
+        private
+
+        # Process all entity types or a specific one
+        def process_entities(entity_type, qudt_data, direction, output_dir,
+include_potential)
+          if entity_type && ENTITY_TYPES.include?(entity_type)
+            process_entity_type(entity_type, qudt_data, direction, output_dir,
+                                include_potential)
+          else
+            ENTITY_TYPES.each do |type|
+              process_entity_type(type, qudt_data, direction, output_dir,
+                                  include_potential)
+            end
+          end
+        end
+
+        # Process a specific entity type
+        def process_entity_type(entity_type, qudt_data, direction, output_dir,
+include_potential = false)
+          puts "\n========== Processing #{entity_type.upcase} References ==========\n"
+
+          db_entities = @db.send(entity_type)
+          qudt_entities = TtlParser.get_entities_from_qudt(entity_type,
+                                                           qudt_data)
+
+          puts "Found #{qudt_entities.size} #{entity_type} in QUDT"
+          puts "Found #{db_entities.size} #{entity_type} in database"
+
+          if %w[from_qudt
+                both].include?(direction)
+            check_from_qudt(entity_type, qudt_entities, db_entities, output_dir,
+                            include_potential)
+          end
+
+          return unless %w[to_qudt both].include?(direction)
+
+          check_to_qudt(entity_type, qudt_entities, db_entities, output_dir,
+                        include_potential)
+        end
+
+        # Validation helpers
+        def validate_parameters(direction, ttl_dir, source_type)
+          unless %w[to_qudt from_qudt both].include?(direction)
+            raise Unitsdb::Errors::InvalidParameterError,
+                  "Invalid direction '#{direction}': must be 'to_qudt', 'from_qudt', or 'both'"
+          end
+
+          return unless source_type == :file && ttl_dir && !Dir.exist?(ttl_dir)
+
+          raise Unitsdb::Errors::FileNotFoundError,
+                "TTL directory not found: #{ttl_dir}"
+        end
+
+        # Direction handler: QUDT → UnitsDB
+        def check_from_qudt(entity_type, qudt_entities, db_entities,
+output_dir, include_potential = false)
+          Formatter.print_direction_header("QUDT → UnitsDB")
+
+          matches, missing_matches, unmatched_qudt = Matcher.match_qudt_to_db(
+            entity_type, qudt_entities, db_entities
+          )
+
+          # Print results
+          Formatter.display_qudt_results(entity_type, matches, missing_matches,
+                                         unmatched_qudt)
+
+          # Display detailed missing QUDT entities analysis
+          Formatter.display_missing_qudt_entities(entity_type, unmatched_qudt)
+
+          # Update references if needed
+          return unless output_dir && !missing_matches.empty?
+
+          output_file = File.join(output_dir, "#{entity_type}.yaml")
+          Updater.update_references(entity_type, missing_matches, db_entities,
+                                    output_file, include_potential)
+          puts "\nUpdated references written to #{output_file}"
+        end
+
+        # Direction handler: UnitsDB → QUDT
+        def check_to_qudt(entity_type, qudt_entities, db_entities, output_dir,
+include_potential = false)
+          Formatter.print_direction_header("UnitsDB → QUDT")
+
+          matches, missing_refs, unmatched_db = Matcher.match_db_to_qudt(
+            entity_type, qudt_entities, db_entities
+          )
+
+          # Print results
+          Formatter.display_db_results(entity_type, matches, missing_refs,
+                                       unmatched_db)
+
+          # Update references if needed
+          return unless output_dir && !missing_refs.empty?
+
+          output_file = File.join(output_dir, "#{entity_type}.yaml")
+          Updater.update_references(entity_type, missing_refs, db_entities,
+                                    output_file, include_potential)
+          puts "\nUpdated references written to #{output_file}"
+        end
+      end
+    end
+  end
+end