factorix 0.5.0

data/lib/factorix/cli/commands/mod/list.rb

@@ -0,0 +1,372 @@
+# frozen_string_literal: true
+
+module Factorix
+  class CLI
+    module Commands
+      module MOD
+        # List installed MODs
+        class List < Base
+          # @!parse
+          #   # @return [Dry::Logger::Dispatcher]
+          #   attr_reader :logger
+          #   # @return [Factorix::Runtime]
+          #   attr_reader :runtime
+          #   # @return [Factorix::API::MODPortalAPI]
+          #   attr_reader :mod_portal_api
+          include Import[:logger, :runtime, :mod_portal_api]
+
+          desc "List installed MOD(s)"
+
+          example [
+            "             # List all installed MOD(s)",
+            "--enabled    # List only enabled MOD(s)",
+            "--outdated   # List MOD(s) with available updates",
+            "--json       # Output in JSON format"
+          ]
+
+          option :enabled, type: :flag, default: false, desc: "Show only enabled MOD(s)"
+          option :disabled, type: :flag, default: false, desc: "Show only disabled MOD(s)"
+          option :errors, type: :flag, default: false, desc: "Show only MOD(s) with dependency errors"
+          option :outdated, type: :flag, default: false, desc: "Show only MOD(s) with available updates"
+          option :json, type: :flag, default: false, desc: "Output in JSON format"
+
+          MODInfo = Data.define(:name, :version, :enabled, :error, :latest_version)
+
+          # MOD information for display
+          #
+          # This class encapsulates MOD information for display purposes,
+          # including the MOD name, version, enabled status, error messages,
+          # and latest available version.
+          class MODInfo
+            # @!attribute [r] name
+            #   @return [String] MOD name
+            # @!attribute [r] version
+            #   @return [MODVersion] MOD version
+            # @!attribute [r] enabled
+            #   @return [Boolean] enabled status
+            # @!attribute [r] error
+            #   @return [String, nil] error message if any
+            # @!attribute [r] latest_version
+            #   @return [MODVersion, nil] latest version available on portal
+
+            # Get the display status string
+            #
+            # @return [String] "error", "enabled", or "disabled"
+            def status
+              return "error" if error
+
+              enabled ? "enabled" : "disabled"
+            end
+
+            # Check if a newer version is available
+            #
+            # @return [Boolean] true if latest_version is newer than current version
+            def outdated?
+              return false unless latest_version
+
+              latest_version > version
+            end
+          end
+
+          # Execute the list command
+          #
+          # @param enabled [Boolean] show only enabled MODs
+          # @param disabled [Boolean] show only disabled MODs
+          # @param errors [Boolean] show only MODs with dependency errors
+          # @param outdated [Boolean] show only MODs with available updates
+          # @param json [Boolean] output in JSON format
+          # @return [void]
+          def call(enabled:, disabled:, errors:, outdated:, json:, **)
+            validate_filter_options!(enabled:, disabled:, errors:, outdated:)
+
+            mod_list = MODList.load
+            presenter = Progress::Presenter.new(title: "\u{1F50D}\u{FE0E} Scanning MOD(s)", output: $stderr)
+            handler = Progress::ScanHandler.new(presenter)
+            installed_mods = InstalledMOD.all(handler:)
+            graph = Dependency::Graph::Builder.build(installed_mods:, mod_list:)
+
+            validator = Dependency::Validator.new(graph:, mod_list:, installed_mods:)
+            validation_result = validator.validate
+
+            mod_infos = build_mod_infos(installed_mods, mod_list, validation_result)
+            total_count = mod_infos.size
+
+            # Apply filters
+            mod_infos = apply_filters(mod_infos, enabled:, disabled:, errors:, outdated:)
+
+            # Sort
+            mod_infos = sort_mods(mod_infos)
+
+            # Determine active filter for summary
+            active_filter = if enabled then :enabled
+                            elsif disabled then :disabled
+                            elsif errors then :errors
+                            elsif outdated then :outdated
+                            end
+
+            # Output
+            if json
+              output_json(mod_infos)
+            else
+              output_table(mod_infos, show_latest: outdated, active_filter:, total_count:)
+            end
+          end
+
+          # Validate that conflicting filter options are not specified together
+          #
+          # @param enabled [Boolean] show only enabled MODs
+          # @param disabled [Boolean] show only disabled MODs
+          # @param errors [Boolean] show only MODs with dependency errors
+          # @param outdated [Boolean] show only MODs with available updates
+          # @return [void]
+          # @raise [InvalidArgumentError] if conflicting options are specified
+          private def validate_filter_options!(enabled:, disabled:, errors:, outdated:)
+            filters = []
+            filters << "--enabled" if enabled
+            filters << "--disabled" if disabled
+            filters << "--errors" if errors
+            filters << "--outdated" if outdated
+
+            return if filters.size <= 1
+
+            raise InvalidArgumentError, "Cannot combine #{filters.join(", ")} options"
+          end
+
+          # Build list of MOD info from installed MODs
+          #
+          # @param installed_mods [Array<InstalledMOD>] installed MODs
+          # @param mod_list [MODList] MOD list with enabled status
+          # @param validation_result [Dependency::ValidationResult] validation result with errors
+          # @return [Array<MODInfo>] MOD info list
+          private def build_mod_infos(installed_mods, mod_list, validation_result)
+            grouped = installed_mods.group_by(&:mod)
+            error_map = build_error_map(validation_result)
+
+            grouped.map {|mod, versions|
+              display_version = determine_display_version(mod, versions, mod_list)
+              enabled = mod_list.exist?(mod) && mod_list.enabled?(mod)
+              error = error_map[mod.name]
+
+              MODInfo.new(name: mod.name, version: display_version, enabled:, error:, latest_version: nil)
+            }
+          end
+
+          # Build a map of MOD name to error messages from validation result
+          #
+          # @param validation_result [Dependency::ValidationResult] validation result
+          # @return [Hash<String, String>] map of MOD name to error message
+          private def build_error_map(validation_result)
+            error_map = {}
+
+            validation_result.errors.each do |error|
+              mod = error.mod
+              next unless mod
+
+              # Use the first error for each MOD
+              error_map[mod.name] ||= error.message
+            end
+
+            error_map
+          end
+
+          # Determine which version of a MOD to display
+          #
+          # Returns the specified version from mod-list.json if present,
+          # otherwise returns the latest installed version.
+          #
+          # @param mod [MOD] the MOD
+          # @param versions [Array<InstalledMOD>] installed versions of the MOD
+          # @param mod_list [MODList] MOD list with enabled status and version
+          # @return [MODVersion] the version to display
+          private def determine_display_version(mod, versions, mod_list)
+            if mod_list.exist?(mod)
+              specified_version = mod_list.version(mod)
+              return specified_version if specified_version
+            end
+
+            versions.map(&:version).max
+          end
+
+          # Apply filters to MOD info list
+          #
+          # @param mod_infos [Array<MODInfo>] MOD info list
+          # @param enabled [Boolean] show only enabled MODs
+          # @param disabled [Boolean] show only disabled MODs
+          # @param errors [Boolean] show only MODs with dependency errors
+          # @param outdated [Boolean] show only MODs with available updates
+          # @return [Array<MODInfo>] filtered MOD info list
+          private def apply_filters(mod_infos, enabled:, disabled:, errors:, outdated:)
+            if enabled
+              mod_infos = mod_infos.select(&:enabled)
+            elsif disabled
+              mod_infos = mod_infos.reject(&:enabled)
+            elsif errors
+              mod_infos = mod_infos.select(&:error)
+            elsif outdated
+              mod_infos = fetch_latest_versions(mod_infos)
+              mod_infos = mod_infos.select(&:outdated?)
+            end
+
+            mod_infos
+          end
+
+          # Default number of parallel jobs for fetching latest versions
+          DEFAULT_JOBS = 4
+          private_constant :DEFAULT_JOBS
+
+          # Fetch latest versions from portal for outdated check
+          #
+          # @param mod_infos [Array<MODInfo>] MOD info list
+          # @return [Array<MODInfo>] MOD info list with latest versions
+          private def fetch_latest_versions(mod_infos)
+            # Separate base/expansion from regular MODs
+            base_and_expansions, regular_mods = mod_infos.partition {|info|
+              mod = Factorix::MOD[name: info.name]
+              mod.base? || mod.expansion?
+            }
+
+            # Only show progress for MOD(s) that need API calls
+            presenter = Progress::Presenter.new(title: "\u{1F50D}\u{FE0E} Checking for updates", output: $stderr)
+            presenter.start(total: regular_mods.size)
+
+            pool = Concurrent::FixedThreadPool.new(DEFAULT_JOBS)
+
+            futures = regular_mods.map {|info|
+              Concurrent::Future.execute(executor: pool) do
+                result = fetch_latest_version_for_mod(info)
+                presenter.update
+                result
+              end
+            }
+
+            results = futures.map(&:value!)
+            presenter.finish
+
+            # Combine base/expansion (unchanged) with fetched results
+            base_and_expansions + results
+          ensure
+            pool&.shutdown
+            pool&.wait_for_termination
+          end
+
+          # Fetch latest version for a single MOD
+          #
+          # @param info [MODInfo] MOD info
+          # @return [MODInfo] MOD info with latest version
+          private def fetch_latest_version_for_mod(info)
+            portal_info = mod_portal_api.get_mod(info.name)
+            latest = portal_info[:releases]&.map {|r| MODVersion.from_string(r[:version]) }&.max
+            MODInfo.new(
+              name: info.name,
+              version: info.version,
+              enabled: info.enabled,
+              error: info.error,
+              latest_version: latest
+            )
+          rescue MODNotOnPortalError
+            logger.debug("MOD not found on portal", mod: info.name)
+            info
+          end
+
+          # Sort MODs: base -> expansion (alphabetically) -> others (alphabetically)
+          #
+          # @param mod_infos [Array<MODInfo>] MOD info list
+          # @return [Array<MODInfo>] sorted MOD info list
+          private def sort_mods(mod_infos)
+            mod_infos.sort_by do |info|
+              mod = Factorix::MOD[name: info.name]
+              if mod.base?
+                [0, info.name]
+              elsif mod.expansion?
+                [1, info.name]
+              else
+                [2, info.name]
+              end
+            end
+          end
+
+          # Output MOD list in table format
+          #
+          # @param mod_infos [Array<MODInfo>] MOD info list
+          # @param show_latest [Boolean] show LATEST column for outdated MODs
+          # @param active_filter [Symbol, nil] active filter (:enabled, :disabled, :errors, :outdated, or nil)
+          # @param total_count [Integer] total MOD count before filtering
+          # @return [void]
+          private def output_table(mod_infos, show_latest: false, active_filter: nil, total_count: 0)
+            if mod_infos.empty?
+              message = active_filter ? "No MOD(s) match the specified criteria" : "No MOD(s) found"
+              say message, prefix: :info
+              return
+            end
+
+            # Calculate column widths
+            name_width = [mod_infos.map {|m| m.name.length }.max, 4].max
+            version_width = [mod_infos.map {|m| m.version.to_s.length }.max, 7].max
+
+            if show_latest
+              latest_width = [mod_infos.map {|m| m.latest_version&.to_s&.length || 0 }.max, 6].max
+
+              # Header with LATEST column
+              puts "%-#{name_width}s  %-#{version_width}s  %-#{latest_width}s  %s" % %w[NAME VERSION LATEST STATUS]
+
+              # Rows with LATEST column
+              mod_infos.each do |info|
+                puts "%-#{name_width}s  %-#{version_width}s  %-#{latest_width}s  %s" % [info.name, info.version, info.latest_version, info.status]
+              end
+            else
+              # Header
+              puts "%-#{name_width}s  %-#{version_width}s  %s" % %w[NAME VERSION STATUS]
+
+              # Rows
+              mod_infos.each do |info|
+                puts "%-#{name_width}s  %-#{version_width}s  %s" % [info.name, info.version, info.status]
+              end
+            end
+
+            say format_summary(mod_infos.size, active_filter, total_count), prefix: :info
+          end
+
+          # Format summary message based on active filter
+          #
+          # @param count [Integer] filtered MOD count
+          # @param active_filter [Symbol, nil] active filter
+          # @param total_count [Integer] total MOD count
+          # @return [String] formatted summary message
+          private def format_summary(count, active_filter, total_count)
+            case active_filter
+            when :enabled
+              "Summary: #{count} enabled MOD(s), #{total_count} total MOD(s)"
+            when :disabled
+              "Summary: #{count} disabled MOD(s), #{total_count} total MOD(s)"
+            when :errors
+              "Summary: #{count} MOD(s) with errors, #{total_count} total MOD(s)"
+            when :outdated
+              "Summary: #{count} outdated MOD(s), #{total_count} total MOD(s)"
+            else
+              "Summary: #{count} MOD(s)"
+            end
+          end
+
+          # Output MOD list in JSON format
+          #
+          # @param mod_infos [Array<MODInfo>] MOD info list
+          # @return [void]
+          private def output_json(mod_infos)
+            data = mod_infos.map {|info|
+              {
+                name: info.name,
+                version: info.version.to_s,
+                enabled: info.enabled,
+                error: info.error
+              }.tap do |h|
+                h[:latest_version] = info.latest_version.to_s if info.latest_version
+              end
+            }
+
+            puts JSON.pretty_generate(data)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/factorix/cli/commands/mod/search.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Factorix
+  class CLI
+    module Commands
+      module MOD
+        # Search MODs on Factorio MOD Portal
+        class Search < Base
+          # @!parse
+          #   # @return [Portal]
+          #   attr_reader :portal
+          #   # @return [Runtime]
+          #   attr_reader :runtime
+          include Import[:portal, :runtime]
+
+          desc "Search MOD(s) on Factorio MOD Portal"
+
+          example [
+            "                           # List MOD(s) for current Factorio version",
+            "mod-a mod-b                # Search specific MOD(s) by name",
+            "--sort name                # List MOD(s) sorted by name",
+            "--page 2 --page-size 25    # Paginate results",
+            "--no-hide-deprecated       # Include deprecated MOD(s)",
+            "--version 1.1              # Filter by specific Factorio version"
+          ]
+
+          argument :mod_names, type: :array, required: false, default: [], desc: "MOD names to search"
+
+          option :hide_deprecated, type: :boolean, default: true, desc: "Hide deprecated MOD(s)"
+          option :page, type: :integer, default: 1, desc: "Page number"
+          option :page_size, type: :integer, default: 25, desc: "Results per page (max 500)"
+          option :sort, type: :string, values: %w[name created_at updated_at], desc: "Sort field"
+          option :sort_order, type: :string, values: %w[asc desc], desc: "Sort order"
+          option :version, type: :string, desc: "Filter by Factorio version (default: installed version)"
+          option :json, type: :flag, default: false, desc: "Output in JSON format"
+
+          # Execute the search command
+          #
+          # @param mod_names [Array<String>] MOD names to search
+          # @param hide_deprecated [Boolean] Hide deprecated MODs
+          # @param page [Integer] Page number
+          # @param page_size [Integer] Results per page
+          # @param sort [String, nil] Sort field
+          # @param sort_order [String, nil] Sort order
+          # @param version [String, nil] Factorio version filter
+          # @param json [Boolean] Output in JSON format
+          # @return [void]
+          def call(mod_names: [], hide_deprecated: true, page: 1, page_size: 25, sort: nil, sort_order: nil, version: nil, json: false, **)
+            version ||= default_factorio_version
+
+            mods = portal.list_mods(*mod_names, hide_deprecated: hide_deprecated || nil, page:, page_size:, sort:, sort_order:, version:)
+
+            if json
+              output_json(mods)
+            else
+              output_table(mods)
+            end
+          end
+
+          private def output_json(mods)
+            puts JSON.pretty_generate(mods.map {|mod| mod_to_hash(mod) })
+          end
+
+          private def mod_to_hash(mod)
+            {
+              name: mod.name,
+              title: mod.title,
+              owner: mod.owner,
+              summary: mod.summary,
+              downloads_count: mod.downloads_count,
+              category: mod.category.value,
+              score: mod.score,
+              thumbnail: mod.thumbnail&.to_s,
+              latest_release: mod.latest_release && release_to_hash(mod.latest_release),
+              releases: mod.releases.map {|r| release_to_hash(r) }
+            }
+          end
+
+          private def release_to_hash(release)
+            {
+              version: release.version.to_s,
+              file_name: release.file_name,
+              released_at: release.released_at.iso8601,
+              factorio_version: release.info_json[:factorio_version],
+              sha1: release.sha1
+            }
+          end
+
+          private def output_table(mods)
+            if mods.empty?
+              say "No MOD(s) found", prefix: :info
+              return
+            end
+
+            rows = mods.map {|mod| format_row(mod) }
+
+            headers = %w[NAME TITLE CATEGORY OWNER LATEST]
+            widths = headers.map.with_index {|h, i| [h.length, *rows.map {|r| r[i].to_s.length }].max }
+
+            puts format_table_row(headers, widths)
+
+            rows.each do |row|
+              puts format_table_row(row, widths)
+            end
+
+            say "#{mods.size} MOD(s) found", prefix: :info
+          end
+
+          private def format_table_row(values, widths)
+            pairs = values.zip(widths)
+            pairs.map {|v, w| v.to_s.ljust(w) }.join("  ")
+          end
+
+          private def format_row(mod)
+            [
+              mod.name,
+              mod.title,
+              mod.category.name,
+              mod.owner,
+              mod.latest_release&.version&.to_s
+            ]
+          end
+
+          private def default_factorio_version
+            base_mod = InstalledMOD.from_directory(runtime.data_dir + "base")
+            "#{base_mod.version.major}.#{base_mod.version.minor}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/factorix/cli/commands/mod/settings/dump.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Factorix
+  class CLI
+    module Commands
+      module MOD
+        module Settings
+          # Dump MOD settings to JSON format
+          class Dump < Base
+            # @!parse
+            #   # @return [Runtime::Base]
+            #   attr_reader :runtime
+            include Import[:runtime]
+
+            desc "Dump MOD settings to JSON format"
+
+            example [
+              "                        # Dump to stdout",
+              "-o settings.json        # Dump to file",
+              "/path/to/mod-settings.dat -o out.json   # Dump specific file"
+            ]
+
+            argument :settings_file, type: :string, required: false, desc: "Path to mod-settings.dat file"
+            option :output, type: :string, aliases: ["-o"], desc: "Output file path"
+
+            # Execute the dump command
+            #
+            # @param settings_file [String, nil] Path to mod-settings.dat file
+            # @param output [String, nil] Output file path
+            # @return [void]
+            def call(settings_file: nil, output: nil, **)
+              # Load MOD settings
+              settings_path = settings_file ? Pathname(settings_file) : runtime.mod_settings_path
+              settings = MODSettings.load(settings_path)
+
+              # Convert to JSON format
+              data = build_hash(settings)
+              output_string = JSON.pretty_generate(data)
+
+              # Write to output
+              if output
+                Pathname(output).write(output_string)
+              else
+                puts output_string
+              end
+            end
+
+            # Build hash from MODSettings for JSON output
+            #
+            # @param settings [Factorix::MODSettings] The MOD settings to convert
+            # @return [Hash] Hash representation of the settings
+            private def build_hash(settings)
+              result = {
+                "game_version" => settings.game_version.to_s
+              }
+
+              settings.each_section do |section|
+                section_hash = {}
+                section.each do |key, value|
+                  section_hash[key] = convert_value_for_output(value)
+                end
+                result[section.name] = section_hash unless section_hash.empty?
+              end
+
+              result
+            end
+
+            # Convert value for JSON output (handle SignedInteger/UnsignedInteger)
+            #
+            # @param value [Object] The value to convert
+            # @return [Object] Converted value
+            private def convert_value_for_output(value)
+              case value
+              when SerDes::SignedInteger, SerDes::UnsignedInteger
+                # Integer(...) does not accept Integer instance
+                Integer(value.to_s, 10)
+              else
+                value
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/factorix/cli/commands/mod/settings/restore.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Factorix
+  class CLI
+    module Commands
+      module MOD
+        module Settings
+          # Restore MOD settings from JSON format
+          class Restore < Base
+            require_game_stopped!
+            backup_support!
+
+            # @!parse
+            #   # @return [Runtime::Base]
+            #   attr_reader :runtime
+            include Import[:runtime]
+
+            desc "Restore MOD settings from JSON format"
+
+            example [
+              "-i settings.json        # Restore from file",
+              "                        # Restore from stdin"
+            ]
+
+            argument :settings_file, type: :string, required: false, desc: "Path to mod-settings.dat file to write"
+            option :input, type: :string, aliases: ["-i"], desc: "Input file path"
+
+            # Execute the restore command
+            #
+            # @param input [String, nil] Path to JSON file
+            # @param settings_file [String, nil] Path to mod-settings.dat file
+            # @return [void]
+            def call(input: nil, settings_file: nil, **)
+              # Read input
+              if input
+                input_path = Pathname(input)
+                input_string = input_path.read
+              else
+                # Read from stdin
+                input_string = $stdin.read
+              end
+
+              # Parse input
+              data = JSON.parse(input_string)
+              settings = build_settings(data)
+
+              # Determine output path
+              output_path = settings_file ? Pathname(settings_file) : runtime.mod_settings_path
+
+              # Backup existing file if it exists
+              backup_if_exists(output_path)
+
+              # Save settings
+              settings.save(output_path)
+            end
+
+            # Build MODSettings from parsed JSON data
+            #
+            # @param data [Hash] Parsed JSON data
+            # @return [Factorix::MODSettings] The MOD settings
+            private def build_settings(data)
+              game_version = GameVersion.from_string(data["game_version"])
+              sections = {}
+
+              MODSettings::VALID_SECTIONS.each do |section_name|
+                section = MODSettings::Section.new(section_name)
+                if data.key?(section_name)
+                  data[section_name].each do |key, value|
+                    section[key] = convert_value_for_input(value)
+                  end
+                end
+                sections[section_name] = section
+              end
+
+              MODSettings.new(game_version, sections)
+            end
+
+            # Convert value from JSON input (detect integer types)
+            #
+            # @param value [Object] The value to convert
+            # @return [Object] Converted value
+            # @note Factorio MOD settings use signed integers for int-setting type.
+            #       Since JSON doesn't preserve signed/unsigned distinction,
+            #       we use SignedInteger for all integer values.
+            # @see https://wiki.factorio.com/Tutorial:Mod_settings#int-setting
+            private def convert_value_for_input(value)
+              case value
+              when Integer
+                SerDes::SignedInteger.new(value)
+              else
+                value
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end