factorix 0.5.0

data/lib/factorix/cli/commands/confirmable.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Factorix
+  class CLI
+    module Commands
+      # Mixin for commands that require user confirmation
+      #
+      # This module provides:
+      # - --yes option to skip confirmation prompts
+      # - confirm? method to ask for user confirmation
+      #
+      # Prepend this module to commands that need confirmation
+      # (e.g., enable, disable, install, uninstall)
+      module Confirmable
+        # Hook called when this module is prepended to a class
+        # @param base [Class] the class prepending this module
+        def self.prepended(base)
+          base.class_eval do
+            option :yes, type: :flag, default: false, aliases: ["-y"], desc: "Skip confirmation prompts"
+          end
+        end
+
+        # Store the --yes flag for use in confirm?
+        # @param options [Hash] command options
+        def call(**options)
+          @yes = options[:yes]
+          super
+        end
+
+        # Ask for user confirmation
+        #
+        # @param message [String] confirmation message to display
+        # @return [Boolean] true if user confirms, false otherwise
+        # @raise [InvalidOperationError] if in quiet mode without --yes flag
+        private def confirm?(message="Do you want to continue?")
+          # --yes flag skips confirmation
+          return true if @yes
+
+          # Cannot prompt in quiet mode
+          if quiet?
+            raise InvalidOperationError, "Cannot prompt for confirmation in quiet mode. Use --yes to proceed automatically."
+          end
+
+          print "#{message} [y/N] "
+          response = $stdin.gets&.strip&.downcase
+
+          # Only explicit y or yes means yes (default is no for safety)
+          response == "y" || response == "yes"
+        end
+      end
+    end
+  end
+end

data/lib/factorix/cli/commands/download_support.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "concurrent/executor/fixed_thread_pool"
+require "concurrent/future"
+
+module Factorix
+  class CLI
+    module Commands
+      # Provides common download functionality for MOD commands
+      #
+      # This module extracts the common download logic used across
+      # Download, Install, and Sync commands.
+      #
+      # @example
+      #   class Install < Base
+      #     include DownloadSupport
+      #
+      #     def call(mod_specs:, **options)
+      #       # ... build targets ...
+      #       download_mods(targets, jobs)
+      #     end
+      #   end
+      module DownloadSupport
+        # Parse MOD specification into mod and version
+        #
+        # @param mod_spec [String] MOD specification (name@version or name@latest or name)
+        # @return [Hash] {mod:, version:} where version is MODVersion or :latest
+        private def parse_mod_spec(mod_spec)
+          parts = mod_spec.split("@", 2)
+          mod = Factorix::MOD[name: parts[0]]
+          version_spec = parts[1]
+          version = case version_spec
+                    when nil, "", "latest" then :latest
+                    else MODVersion.from_string(version_spec)
+                    end
+          {mod:, version:}
+        end
+
+        # Find the appropriate release for a version
+        #
+        # @param mod_info [API::MODInfo] MOD information
+        # @param version [MODVersion, Symbol] Version or :latest
+        # @return [API::Release, nil] The release, or nil if not found
+        private def find_release(mod_info, version)
+          if version == :latest
+            mod_info.releases.max_by(&:released_at)
+          else
+            mod_info.releases.find {|r| r.version == version }
+          end
+        end
+
+        # Find a release compatible with a version requirement
+        #
+        # @param mod_info [API::MODInfo] MOD information
+        # @param version_requirement [Dependency::MODVersionRequirement, nil] Version requirement
+        # @return [API::Release, nil] Compatible release or nil
+        private def find_compatible_release(mod_info, version_requirement)
+          return mod_info.releases.max_by(&:released_at) if version_requirement.nil?
+
+          compatible_releases = mod_info.releases.select {|r| version_requirement.satisfied_by?(r.version) }
+
+          compatible_releases.max_by(&:released_at)
+        end
+
+        # Build install targets from MOD infos
+        #
+        # @param mod_infos [Array<Hash>] MOD infos, each containing:
+        #   - :mod [Factorix::MOD] or :mod_name [String] MOD identifier
+        #   - :mod_info [API::MODInfo] MOD information
+        #   - :release [API::Release] Release to install
+        # @param output_dir [Pathname] Output directory for MOD files
+        # @return [Array<Hash>] Install targets
+        private def build_install_targets(mod_infos, output_dir)
+          mod_infos.map {|info|
+            {
+              mod: info[:mod] || Factorix::MOD[name: info[:mod_name]],
+              mod_info: info[:mod_info],
+              release: info[:release],
+              output_path: output_dir / info[:release].file_name,
+              category: info[:mod_info].category
+            }
+          }
+        end
+
+        # Download MODs in parallel
+        #
+        # @param targets [Array<Hash>] Download targets, each containing:
+        #   - :mod [Factorix::MOD] MOD object
+        #   - :release [API::Release] Release to download
+        #   - :output_path [Pathname] Output file path
+        # @param jobs [Integer] Number of parallel downloads
+        # @return [void]
+        private def download_mods(targets, jobs)
+          multi_presenter = Progress::MultiPresenter.new(title: "\u{1F4E5}\u{FE0E} Downloads")
+
+          pool = Concurrent::FixedThreadPool.new(jobs)
+
+          futures = targets.map {|target|
+            Concurrent::Future.execute(executor: pool) do
+              thread_portal = Application[:portal]
+              thread_downloader = thread_portal.mod_download_api.downloader
+
+              presenter = multi_presenter.register(
+                target[:mod].name,
+                title: target[:release].file_name
+              )
+              handler = Progress::DownloadHandler.new(presenter)
+
+              thread_downloader.subscribe(handler)
+              thread_portal.download_mod(target[:release], target[:output_path])
+              thread_downloader.unsubscribe(handler)
+            end
+          }
+
+          futures.each(&:wait!)
+        ensure
+          pool&.shutdown
+          pool&.wait_for_termination
+        end
+      end
+    end
+  end
+end

data/lib/factorix/cli/commands/launch.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Factorix
+  class CLI
+    module Commands
+      # Launch Factorio game
+      #
+      # This command launches the Factorio game executable with optional arguments.
+      # By default, the game is launched asynchronously (in the background), but certain
+      # options like --help and --dump-* are automatically detected and run synchronously.
+      class Launch < Base
+        require_game_stopped!
+        # Game options that require synchronous execution
+        #
+        # These options output information and exit immediately, so we should
+        # wait for them to complete rather than running them in the background.
+        SYNCHRONOUS_OPTIONS = %w[
+          --dump-data
+          --dump-icon-sprites
+          --dump-prototype-locale
+          --help
+          --version
+        ].freeze
+        private_constant :SYNCHRONOUS_OPTIONS
+
+        # @!parse
+        #   # @return [Runtime::Base]
+        #   attr_reader :runtime
+        #   # @return [Dry::Logger::Dispatcher]
+        #   attr_reader :logger
+        include Import[:runtime, :logger]
+
+        desc "Launch Factorio game"
+
+        example [
+          "                              # Launch Factorio",
+          "-- --help                     # Show Factorio help",
+          "-- --benchmark save.zip       # Run benchmark"
+        ]
+
+        option :wait, type: :flag, default: false, aliases: ["-w"], desc: "Wait for the game to finish"
+
+        # Execute the launch command
+        #
+        # @param wait [Boolean] whether to wait for the game to finish
+        # @param args [Array<String>] additional arguments to pass to Factorio
+        # @return [void]
+        def call(wait: false, args: [], **)
+          logger.info("Launching Factorio", args:)
+
+          async = args.none? {|arg| SYNCHRONOUS_OPTIONS.include?(arg) }
+
+          runtime.launch(*args, async:)
+          logger.info("Factorio launched successfully", async:)
+
+          return unless async && wait
+
+          logger.debug("Waiting for game to start")
+          wait_while { !runtime.running? }
+          logger.debug("Game started, waiting for termination")
+          wait_while { runtime.running? }
+          logger.info("Game terminated")
+        end
+
+        # Wait while a condition is true
+        #
+        # @yield the condition to check
+        # @return [void]
+        private def wait_while
+          loop do
+            break unless yield
+
+            sleep 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/factorix/cli/commands/man.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Factorix
+  class CLI
+    module Commands
+      # Display the Factorix manual page
+      #
+      # This command opens the man page for factorix using the system's man command.
+      #
+      # @example
+      #   $ factorix man
+      class Man < Base
+        desc "Display the Factorix manual page"
+
+        # Execute the man command
+        #
+        # @return [void]
+        # @raise [CommandNotFoundError] if man command is not available
+        def call(**)
+          system("command -v man > /dev/null 2>&1")
+          raise CommandNotFoundError, "man command is not available on this system" unless $?.success?
+
+          man_page = File.expand_path("../../../../doc/factorix.1", __dir__)
+          exec "man", man_page
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Factorix
+  class CLI
+    module Commands
+      module MOD
+        # Validate MOD dependencies without making changes
+        class Check < Base
+          # @!parse
+          #   # @return [Dry::Logger::Dispatcher]
+          #   attr_reader :logger
+          #   # @return [Factorix::Runtime]
+          #   attr_reader :runtime
+          include Import[:logger, :runtime]
+
+          desc "Validate MOD dependencies"
+
+          example [
+            "   # Validate all MOD dependencies"
+          ]
+
+          # Execute the check command
+          #
+          # @return [void]
+          def call(**)
+            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:)
+            result = validator.validate
+
+            display_result(result, graph)
+
+            raise ValidationError, "MOD dependency validation failed" unless result.valid?
+          end
+
+          private def display_result(result, graph)
+            say "Validating MOD dependencies...", prefix: :info
+
+            if result.valid? && !result.warnings?
+              display_success_messages
+            end
+
+            display_warnings(result) if result.warnings?
+            display_errors(result) if result.errors?
+            display_suggestions(result) if result.suggestions?
+
+            display_summary(result, graph)
+          end
+
+          private def display_success_messages
+            say "All enabled MOD(s) have their required dependencies satisfied", prefix: :success
+            say "No circular dependencies detected", prefix: :success
+            say "No conflicting MOD(s) are enabled simultaneously", prefix: :success
+          end
+
+          private def display_warnings(result)
+            say "Warnings:", prefix: :warn
+            result.warnings.each do |warning|
+              say "  - #{warning.message}"
+            end
+          end
+
+          private def display_errors(result)
+            say "Errors:", prefix: :error
+            result.errors.each do |error|
+              say "  - #{error.message}"
+            end
+          end
+
+          private def display_suggestions(result)
+            say "Suggestions:", prefix: :info
+            result.suggestions.each do |suggestion|
+              say "  - #{suggestion.message}"
+            end
+          end
+
+          private def display_summary(result, graph)
+            enabled_count = graph.nodes.count(&:enabled?)
+            parts = ["#{enabled_count} enabled MOD#{"s" unless enabled_count == 1}"]
+
+            if result.errors?
+              parts << "#{result.errors.size} error#{"s" unless result.errors.size == 1}"
+            end
+
+            if result.warnings?
+              parts << "#{result.warnings.size} warning#{"s" unless result.warnings.size == 1}"
+            end
+
+            say "Summary: #{parts.join(", ")}", prefix: :info
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module Factorix
+  class CLI
+    module Commands
+      module MOD
+        # Disable MODs in mod-list.json with reverse dependency resolution
+        class Disable < Base
+          confirmable!
+          require_game_stopped!
+          backup_support!
+
+          # @!parse
+          #   # @return [Dry::Logger::Dispatcher]
+          #   attr_reader :logger
+          #   # @return [Factorix::Runtime]
+          #   attr_reader :runtime
+          include Import[:logger, :runtime]
+
+          desc "Disable MOD(s) in mod-list.json (recursively disables dependent MOD(s))"
+
+          example [
+            "some-mod         # Disable single MOD",
+            "mod-a mod-b      # Disable multiple MOD(s)",
+            "--all            # Disable all MOD(s) except base"
+          ]
+
+          argument :mod_names, type: :array, required: false, desc: "MOD names to disable"
+
+          option :all, type: :flag, default: false, desc: "Disable all MOD(s) (except base)"
+
+          # Execute the disable command
+          #
+          # @param mod_names [Array<String>] MOD names to disable
+          # @param all [Boolean] Whether to disable all MODs
+          # @return [void]
+          def call(mod_names: [], all: false, **)
+            validate_arguments(mod_names, all)
+
+            # Without validation to allow fixing issues
+            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:)
+
+            target_mods = if all
+                            plan_disable_all(graph)
+                          else
+                            mod_names.map {|name| Factorix::MOD[name:] }
+                          end
+
+            validate_target_mods(target_mods, graph)
+            mods_to_disable = plan_with_dependents(target_mods, graph)
+
+            show_plan(mods_to_disable)
+            return if mods_to_disable.empty?
+            return unless confirm?("Do you want to disable these MOD(s)?")
+
+            execute_plan(mods_to_disable, mod_list)
+            backup_if_exists(runtime.mod_list_path)
+            mod_list.save
+            say "Disabled #{mods_to_disable.size} MOD(s)", prefix: :success
+            say "Saved mod-list.json", prefix: :success
+            logger.debug("Saved mod-list.json")
+          end
+
+          # Validate command arguments
+          #
+          # @param mod_names [Array<String>] MOD names from argument
+          # @param all [Boolean] Whether --all option is specified
+          # @return [void]
+          # @raise [InvalidArgumentError] if arguments are invalid
+          private def validate_arguments(mod_names, all)
+            if all && mod_names.any?
+              raise InvalidArgumentError, "Cannot specify MOD names with --all option"
+            end
+
+            return if all || mod_names.any?
+
+            raise InvalidArgumentError, "Must specify MOD names or use --all option"
+          end
+
+          # Plan which MODs to disable when --all is specified
+          #
+          # @param graph [Factorix::Dependency::Graph] Dependency graph
+          # @return [Array<Factorix::MOD>] MODs to disable (all except base)
+          private def plan_disable_all(graph)
+            graph.nodes.filter_map do |node|
+              mod = node.mod
+              next if mod.base?
+              next unless node.enabled?
+
+              mod
+            end
+          end
+
+          # Validate that all target MODs can be disabled
+          #
+          # @param target_mods [Array<Factorix::MOD>] MODs to validate
+          # @param graph [Factorix::Dependency::Graph] Dependency graph
+          # @return [void]
+          # @raise [InvalidOperationError] if any MOD cannot be disabled
+          private def validate_target_mods(target_mods, graph)
+            target_mods.each do |mod|
+              raise InvalidOperationError, "Cannot disable base MOD" if mod.base?
+
+              unless graph.node?(mod)
+                say "MOD not installed, skipping: #{mod}", prefix: :warn
+                logger.debug("MOD not installed", mod_name: mod.name)
+              end
+            end
+          end
+
+          # Plan disable with automatic dependent resolution
+          #
+          # Finds all enabled MODs that depend on the target MODs recursively.
+          #
+          # @param target_mods [Array<Factorix::MOD>] MODs to disable
+          # @param graph [Factorix::Dependency::Graph] Dependency graph
+          # @return [Array<Factorix::MOD>] MODs to disable (including dependents)
+          private def plan_with_dependents(target_mods, graph)
+            mods_to_disable = Set.new
+            to_process = target_mods.dup
+
+            while (mod = to_process.shift)
+              node = graph.node(mod)
+
+              unless node
+                logger.debug("MOD not installed", mod_name: mod.name)
+                next
+              end
+
+              unless node.enabled?
+                logger.debug("MOD already disabled", mod_name: mod.name)
+                next
+              end
+
+              next if mods_to_disable.include?(mod)
+
+              dependents = graph.find_enabled_dependents(mod)
+
+              dependents.each do |dependent_mod|
+                logger.debug("Found dependent MOD", dependent: dependent_mod.name, dependency: mod.name)
+                to_process << dependent_mod unless mods_to_disable.include?(dependent_mod)
+              end
+
+              mods_to_disable.add(mod)
+            end
+
+            mods_to_disable.to_a
+          end
+
+          # Show the disable plan to user
+          #
+          # @param mods_to_disable [Array<Factorix::MOD>] MODs to disable
+          # @return [void]
+          private def show_plan(mods_to_disable)
+            if mods_to_disable.empty?
+              say "All specified MOD(s) are already disabled", prefix: :info
+              return
+            end
+
+            say "Planning to disable #{mods_to_disable.size} MOD(s):", prefix: :info
+            mods_to_disable.each do |mod|
+              say "  - #{mod}"
+            end
+          end
+
+          # Execute the disable plan
+          #
+          # @param mods_to_disable [Array<Factorix::MOD>] MODs to disable
+          # @param mod_list [Factorix::MODList] MOD list to modify
+          # @return [void]
+          private def execute_plan(mods_to_disable, mod_list)
+            return if mods_to_disable.empty?
+
+            mods_to_disable.each do |mod|
+              mod_list.disable(mod)
+              say "Disabled #{mod}", prefix: :success
+              logger.debug("Disabled MOD", mod_name: mod.name)
+            end
+          end
+        end
+      end
+    end
+  end
+end