factorix 0.5.0

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

@@ -0,0 +1,325 @@
+# frozen_string_literal: true
+
+module Factorix
+  class CLI
+    module Commands
+      module MOD
+        # Uninstall MODs from MOD directory
+        class Uninstall < 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 "Uninstall MOD(s) from MOD directory"
+
+          example [
+            "some-mod         # Uninstall all versions of MOD",
+            "some-mod@1.2.0   # Uninstall specific version",
+            "--all            # Uninstall all MOD(s)"
+          ]
+
+          argument :mod_specs, type: :array, required: false, desc: "MOD specifications (name@version or name)"
+          option :all, type: :flag, default: false, desc: "Uninstall all MOD(s) (base remains enabled, expansions disabled, others removed)"
+
+          # Execute the uninstall command
+          #
+          # @param mod_specs [Array<String>] MOD specifications
+          # @param all [Boolean] Uninstall all MODs
+          # @return [void]
+          def call(mod_specs: [], all: false, **)
+            # Validate arguments
+            if all && mod_specs.any?
+              raise InvalidArgumentError, "Cannot specify MOD names with --all option"
+            end
+
+            unless all || mod_specs.any?
+              raise InvalidArgumentError, "Must specify MOD names or use --all option"
+            end
+
+            # Load current state (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:)
+
+            # Determine uninstall targets
+            uninstall_targets = if all
+                                  plan_uninstall_all(graph, installed_mods)
+                                else
+                                  # Parse mod specs to extract MOD and optional version
+                                  mod_specs.map {|spec| parse_mod_spec(spec) }
+                                end
+
+            targets_to_uninstall = plan_uninstall(uninstall_targets, graph, installed_mods, all:)
+
+            if all
+              expansions_to_disable = graph.nodes.count {|node|
+                mod = node.mod
+                mod.expansion? && mod_list.exist?(mod) && mod_list.enabled?(mod)
+              }
+
+              if targets_to_uninstall.empty? && expansions_to_disable.zero?
+                say "No MOD(s) to uninstall or disable", prefix: :info
+                return
+              end
+            elsif targets_to_uninstall.empty?
+              say "No MOD(s) to uninstall", prefix: :info
+              return
+            end
+
+            show_plan(targets_to_uninstall, all:, graph:, mod_list:)
+            return unless confirm?("Do you want to uninstall these MOD(s)?")
+
+            execute_uninstall(targets_to_uninstall, installed_mods, mod_list)
+            disable_expansion_mods(graph, mod_list) if all
+            backup_if_exists(runtime.mod_list_path)
+            mod_list.save
+            say "Uninstalled #{targets_to_uninstall.size} MOD(s)", prefix: :success
+            say "Saved mod-list.json", prefix: :success
+          end
+
+          # Plan uninstall all MODs
+          #
+          # @param graph [Dependency::Graph] Dependency graph
+          # @param installed_mods [Array<InstalledMOD>] All installed MODs
+          # @return [Array<Hash>] Uninstall targets
+          private def plan_uninstall_all(graph, _installed_mods)
+            graph.nodes.filter_map do |node|
+              mod = node.mod
+              next if mod.base? || mod.expansion?
+
+              {mod:, version: nil}
+            end
+          end
+
+          private def parse_mod_spec(mod_spec)
+            if mod_spec.include?("@")
+              mod_name, version_str = mod_spec.split("@", 2)
+              mod = Factorix::MOD[name: mod_name]
+              version = MODVersion.from_string(version_str)
+              {mod:, version:}
+            else
+              mod = Factorix::MOD[name: mod_spec]
+              {mod:, version: nil}
+            end
+          end
+
+          private def plan_uninstall(targets, graph, installed_mods, all: false)
+            targets.filter_map do |target|
+              validate_uninstall_target(target, graph, installed_mods, all:)
+            end
+          end
+
+          # Validate a single uninstall target
+          #
+          # @param target [Hash] Target to validate ({mod:, version:})
+          # @param graph [Dependency::Graph] Dependency graph
+          # @param installed_mods [Array<InstalledMOD>] All installed MODs
+          # @param all [Boolean] Whether this is part of --all uninstall
+          # @return [Hash, nil] The target if valid, nil if should be skipped
+          # @raise [InvalidOperationError] if trying to uninstall base or expansion MOD
+          private def validate_uninstall_target(target, graph, installed_mods, all: false)
+            mod = target[:mod]
+
+            # Check if base/expansion
+            raise InvalidOperationError, "Cannot uninstall base MOD" if mod.base?
+            raise InvalidOperationError, "Cannot uninstall expansion MOD: #{mod}" if mod.expansion?
+
+            # Check if installed
+            unless graph.node?(mod)
+              say "MOD not installed: #{mod}", prefix: :warn
+              logger.debug("MOD not installed", mod_name: mod.name)
+              return nil
+            end
+
+            if target[:version] && !version_installed?(target, installed_mods)
+              say "MOD version not installed: #{format_target(target)}", prefix: :warn
+              logger.debug("MOD version not installed", target: format_target(target))
+              return nil
+            end
+
+            # Skip dependent check for --all since all MODs are being uninstalled
+            check_dependents_with_version(target, graph, installed_mods) unless all
+
+            target
+          end
+
+          # Check if a specific version is installed
+          #
+          # @param target [Hash] Target with version ({mod:, version:})
+          # @param installed_mods [Array<InstalledMOD>] All installed MODs
+          # @return [Boolean] true if version is installed
+          private def version_installed?(target, installed_mods)
+            installed_mods.any? {|im| im.mod == target[:mod] && im.version == target[:version] }
+          end
+
+          # Check for enabled dependents considering remaining versions
+          #
+          # @param target [Hash] Target to check ({mod:, version:})
+          # @param graph [Dependency::Graph] Dependency graph
+          # @param installed_mods [Array<InstalledMOD>] All installed MODs
+          # @return [void]
+          # @raise [DependencyViolationError] if dependencies cannot be satisfied after uninstall
+          private def check_dependents_with_version(target, graph, installed_mods)
+            mod = target[:mod]
+            dependents = graph.find_enabled_dependents(mod)
+            return if dependents.none?
+
+            # Find versions that will remain after this uninstall
+            remaining_versions = if target[:version]
+                                   installed_mods.select {|im| im.mod == mod && im.version != target[:version] }
+                                 else
+                                   [] # Uninstalling all versions
+                                 end
+
+            # Check each dependent to see if remaining versions can satisfy their requirements
+            unsatisfied_dependents = []
+
+            dependents.each do |dependent_mod|
+              # Find dependency edges from dependent to target MOD
+              edges = graph.edges_from(dependent_mod).select {|edge|
+                edge.to_mod == mod && edge.required?
+              }
+
+              edges.each do |edge|
+                # Check if any remaining version satisfies this requirement
+                can_satisfy = remaining_versions.any? {|im| edge.satisfied_by?(im.version) }
+
+                unsatisfied_dependents << dependent_mod unless can_satisfy
+              end
+            end
+
+            return if unsatisfied_dependents.empty?
+
+            raise DependencyViolationError,
+              "Cannot uninstall #{format_target(target)}: " \
+              "the following enabled MOD(s) depend on it: #{unsatisfied_dependents.uniq.join(", ")}"
+          end
+
+          # Show the uninstall plan
+          #
+          # @param targets [Array<Hash>] Targets to uninstall
+          # @param all [Boolean] Whether --all was specified
+          # @param graph [Dependency::Graph] Dependency graph
+          # @param mod_list [MODList] The MOD list
+          # @return [void]
+          private def show_plan(targets, all: false, graph: nil, mod_list: nil)
+            say "Planning to uninstall #{targets.size} MOD(s):", prefix: :info
+            targets.each do |target|
+              say "  - #{format_target(target)}"
+            end
+
+            # If --all, also show expansion MODs to be disabled
+            return unless all && graph && mod_list
+
+            expansions_to_disable = graph.nodes.filter_map {|node|
+              mod = node.mod
+              mod if mod.expansion? && mod_list.exist?(mod) && mod_list.enabled?(mod)
+            }
+
+            return if expansions_to_disable.none?
+
+            say "Expansion MOD(s) to be disabled:", prefix: :info
+            expansions_to_disable.each do |mod|
+              say "  - #{mod}"
+            end
+          end
+
+          # Execute the uninstall
+          #
+          # @param targets [Array<Hash>] Targets to uninstall
+          # @param installed_mods [Array<InstalledMOD>] All installed MODs
+          # @param mod_list [MODList] The MOD list
+          # @return [void]
+          private def execute_uninstall(targets, installed_mods, mod_list)
+            targets.each do |target|
+              mod = target[:mod]
+
+              # Find versions to uninstall
+              mod_versions = if target[:version]
+                               # Uninstall only the specified version
+                               installed_mods.select {|im|
+                                 im.mod == mod && im.version == target[:version]
+                               }
+                             else
+                               # Uninstall all versions
+                               installed_mods.select {|im| im.mod == mod }
+                             end
+
+              # Remove versions from file system
+              mod_versions.each do |installed_mod|
+                remove_mod_files(installed_mod)
+              end
+
+              # Remove from mod-list.json if appropriate
+              should_remove_from_list = if target[:version]
+                                          # Only remove if mod-list references this version or if no versions remain
+                                          remaining_versions = installed_mods.select {|im|
+                                            im.mod == mod && !mod_versions.include?(im)
+                                          }
+                                          remaining_versions.empty?
+                                        else
+                                          # Always remove when uninstalling all versions
+                                          true
+                                        end
+
+              if should_remove_from_list && mod_list.exist?(mod)
+                mod_list.remove(mod)
+                say "Removed #{mod} from mod-list.json", prefix: :success
+              end
+            end
+          end
+
+          # Disable expansion MODs in mod-list.json
+          #
+          # @param graph [Dependency::Graph] Dependency graph
+          # @param mod_list [MODList] The MOD list
+          # @return [void]
+          private def disable_expansion_mods(graph, mod_list)
+            graph.nodes.each do |node|
+              mod = node.mod
+              next unless mod.expansion?
+              next unless mod_list.exist?(mod) && mod_list.enabled?(mod)
+
+              mod_list.disable(mod)
+              say "Disabled expansion MOD: #{mod}", prefix: :success
+              logger.info("Disabled expansion MOD", mod_name: mod.name)
+            end
+          end
+
+          # Remove MOD files from the file system
+          #
+          # @param installed_mod [InstalledMOD] The installed MOD to remove
+          # @return [void]
+          private def remove_mod_files(installed_mod)
+            path = installed_mod.path
+
+            if installed_mod.form == InstalledMOD::ZIP_FORM
+              path.delete
+              logger.info("Removed ZIP file", mod_name: installed_mod.mod.name, version: installed_mod.version.to_s)
+            elsif installed_mod.form == InstalledMOD::DIRECTORY_FORM
+              path.rmtree
+              logger.info("Removed directory", mod_name: installed_mod.mod.name, version: installed_mod.version.to_s)
+            end
+          end
+
+          # Format uninstall target for display
+          #
+          # @param target [Hash] Target to format ({mod:, version:})
+          # @return [String] Formatted string (e.g., "mod-a@1.0.0" or "mod-a")
+          private def format_target(target)
+            target[:version] ? "#{target[:mod]}@#{target[:version]}" : target[:mod].to_s
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require "concurrent/executor/fixed_thread_pool"
+require "concurrent/future"
+
+module Factorix
+  class CLI
+    module Commands
+      module MOD
+        # Update installed MODs to their latest versions
+        class Update < Base
+          confirmable!
+          require_game_stopped!
+          backup_support!
+
+          # @!parse
+          #   # @return [Portal]
+          #   attr_reader :portal
+          #   # @return [Dry::Logger::Dispatcher]
+          #   attr_reader :logger
+          #   # @return [Factorix::Runtime]
+          #   attr_reader :runtime
+          include Import[:portal, :logger, :runtime]
+
+          desc "Update MOD(s) to their latest versions"
+
+          example [
+            "                   # Update all installed MOD(s)",
+            "some-mod           # Update specific MOD",
+            "mod-a mod-b        # Update multiple MOD(s)",
+            "-j 8 mod-a mod-b   # Use 8 parallel downloads"
+          ]
+
+          argument :mod_names, type: :array, required: false, desc: "MOD names to update (all if not specified)"
+          option :jobs, type: :integer, aliases: ["-j"], default: 4, desc: "Number of parallel downloads"
+
+          # Execute the update command
+          #
+          # @param mod_names [Array<String>] MOD names to update
+          # @param jobs [Integer] Number of parallel downloads
+          # @return [void]
+          def call(mod_names: [], jobs: 4, **)
+            presenter = Progress::Presenter.new(title: "\u{1F50D}\u{FE0E} Scanning MOD(s)", output: $stderr)
+            handler = Progress::ScanHandler.new(presenter)
+            installed_mods = InstalledMOD.all(handler:)
+            mod_list = MODList.load
+
+            target_mods = if mod_names.empty?
+                            mods = installed_mods.map(&:mod)
+                            mods.uniq!
+                            mods.reject! {|mod| mod.base? || mod.expansion? }
+                            mods
+                          else
+                            mod_names.map {|name| validate_and_get_mod(name) }
+                          end
+
+            if target_mods.empty?
+              say "No MOD(s) to update", prefix: :info
+              return
+            end
+
+            update_targets = find_update_targets(target_mods, installed_mods, jobs)
+
+            if update_targets.empty?
+              say "All MOD(s) are up to date", prefix: :info
+              return
+            end
+
+            show_plan(update_targets)
+            return unless confirm?("Do you want to update these MOD(s)?")
+
+            execute_updates(update_targets, mod_list, jobs)
+
+            backup_if_exists(runtime.mod_list_path)
+            mod_list.save
+            say "Updated #{update_targets.size} MOD(s)", prefix: :success
+            say "Saved mod-list.json", prefix: :success
+          end
+
+          # Validate MOD name and return MOD object
+          #
+          # @param mod_name [String] MOD name
+          # @return [MOD] MOD object
+          # @raise [InvalidOperationError] if MOD is base or expansion
+          private def validate_and_get_mod(mod_name)
+            mod = Factorix::MOD[name: mod_name]
+
+            raise InvalidOperationError, "Cannot update base MOD" if mod.base?
+            raise InvalidOperationError, "Cannot update expansion MOD: #{mod}" if mod.expansion?
+
+            mod
+          end
+
+          # Find MODs that have available updates
+          #
+          # @param target_mods [Array<MOD>] Target MODs to check
+          # @param installed_mods [Array<InstalledMOD>] All installed MODs
+          # @param jobs [Integer] Number of parallel jobs
+          # @return [Array<Hash>] Update targets with current and latest versions
+          private def find_update_targets(target_mods, installed_mods, jobs)
+            presenter = Progress::Presenter.new(title: "\u{1F50D}\u{FE0E} Checking for updates", output: $stderr)
+            presenter.start(total: target_mods.size)
+
+            pool = Concurrent::FixedThreadPool.new(jobs)
+
+            futures = target_mods.map {|mod|
+              Concurrent::Future.execute(executor: pool) do
+                result = check_mod_for_update(mod, installed_mods)
+                presenter.update
+                result
+              end
+            }
+
+            results = futures.filter_map(&:value!)
+            presenter.finish
+            results
+          ensure
+            pool&.shutdown
+            pool&.wait_for_termination
+          end
+
+          # Check a single MOD for available updates
+          #
+          # @param mod [MOD] MOD to check
+          # @param installed_mods [Array<InstalledMOD>] All installed MODs
+          # @return [Hash, nil] Update target info or nil if no update available
+          private def check_mod_for_update(mod, installed_mods)
+            current_versions = installed_mods.select {|im| im.mod == mod }
+            return nil if current_versions.empty?
+
+            current_version = current_versions.map(&:version).max
+
+            mod_info = portal.get_mod_full(mod.name)
+            latest_release = mod_info.releases.max_by(&:released_at)
+
+            return nil unless latest_release
+            return nil if latest_release.version <= current_version
+
+            {
+              mod:,
+              mod_info:,
+              current_version:,
+              latest_release:,
+              output_path: runtime.mod_dir / latest_release.file_name
+            }
+          rescue MODNotOnPortalError
+            logger.debug("MOD not found on portal", mod: mod.name)
+            nil
+          end
+
+          # Show the update plan
+          #
+          # @param targets [Array<Hash>] Update targets
+          # @return [void]
+          private def show_plan(targets)
+            say "Planning to update #{targets.size} MOD(s):", prefix: :info
+            targets.each do |target|
+              say "  - #{target[:mod]}: #{target[:current_version]} -> #{target[:latest_release].version}"
+            end
+          end
+
+          # Execute the updates
+          #
+          # @param targets [Array<Hash>] Update targets
+          # @param mod_list [MODList] MOD list
+          # @param jobs [Integer] Number of parallel jobs
+          # @return [void]
+          private def execute_updates(targets, mod_list, jobs)
+            download_mods(targets, jobs)
+
+            targets.each do |target|
+              mod = target[:mod]
+
+              if mod_list.exist?(mod)
+                current_enabled = mod_list.enabled?(mod)
+                mod_list.remove(mod)
+                mod_list.add(mod, enabled: current_enabled)
+                say "Updated #{mod} to #{target[:latest_release].version}", prefix: :success
+              else
+                mod_list.add(mod, enabled: true)
+                say "Added #{mod} to mod-list.json", prefix: :success
+              end
+            end
+          end
+
+          # Download MODs in parallel
+          #
+          # @param targets [Array<Hash>] Update targets
+          # @param jobs [Integer] Number of parallel jobs
+          # @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[:latest_release].file_name
+                )
+                handler = Progress::DownloadHandler.new(presenter)
+
+                thread_downloader.subscribe(handler)
+                thread_portal.download_mod(target[:latest_release], target[:output_path])
+                thread_downloader.unsubscribe(handler)
+              end
+            }
+
+            futures.each(&:wait!)
+          ensure
+            pool&.shutdown
+            pool&.wait_for_termination
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Factorix
+  class CLI
+    module Commands
+      module MOD
+        # Upload MOD to Factorio MOD Portal (handles both new and update)
+        class Upload < Base
+          # @!parse
+          #   # @return [Portal]
+          #   attr_reader :portal
+          include Import[:portal]
+
+          desc "Upload MOD to Factorio MOD Portal (handles both new and update)"
+
+          example [
+            "my-mod_1.0.0.zip                           # Upload MOD",
+            "my-mod_1.0.0.zip --category automation     # Upload with category"
+          ]
+
+          argument :file, type: :string, required: true, desc: "Path to MOD zip file"
+          option :description, type: :string, desc: "Markdown description"
+          option :category, type: :string, desc: "MOD category"
+          option :license, type: :string, desc: "License identifier"
+          option :source_url, type: :string, desc: "Repository URL"
+
+          # Execute the upload command
+          #
+          # @param file [String] path to MOD zip file
+          # @param description [String, nil] optional description
+          # @param category [String, nil] optional category
+          # @param license [String, nil] optional license
+          # @param source_url [String, nil] optional source URL
+          # @return [void]
+          # @raise [InvalidArgumentError] if file does not exist, is not a file, or is not a .zip file
+          # @raise [FileFormatError] if zip is invalid or info.json is missing/malformed
+          def call(file:, description: nil, category: nil, license: nil, source_url: nil, **)
+            file_path = Pathname(file)
+
+            raise InvalidArgumentError, "File not found: #{file}" unless file_path.exist?
+            raise InvalidArgumentError, "Not a file: #{file}" unless file_path.file?
+            raise InvalidArgumentError, "File must be a .zip file" if file_path.extname.casecmp(".zip").nonzero?
+
+            mod_name = extract_mod_name(file_path)
+            metadata = build_metadata(description:, category:, license:, source_url:)
+
+            presenter = Progress::Presenter.new(title: "\u{1F4E4} Uploading #{file_path.basename}", output: $stderr)
+
+            uploader = portal.mod_management_api.uploader
+            handler = Progress::UploadHandler.new(presenter)
+            uploader.subscribe(handler)
+
+            begin
+              portal.upload_mod(mod_name, file_path, **metadata)
+              say "Upload completed successfully!", prefix: :success
+            ensure
+              uploader.unsubscribe(handler)
+            end
+          end
+
+          # Extract MOD name from info.json inside zip file
+          #
+          # @param file_path [Pathname] path to zip file
+          # @return [String] MOD name from info.json
+          # @raise [FileFormatError] if info.json not found or invalid
+          private def extract_mod_name(file_path)
+            info = InfoJSON.from_zip(file_path)
+            info.name
+          end
+
+          # Build metadata hash from options
+          #
+          # @param description [String, nil] description
+          # @param category [String, nil] category
+          # @param license [String, nil] license
+          # @param source_url [String, nil] source URL
+          # @return [Hash] metadata hash with symbol keys
+          private def build_metadata(description: nil, category: nil, license: nil, source_url: nil)
+            metadata = {}
+            metadata[:description] = description if description
+            metadata[:category] = category if category
+            metadata[:license] = license if license
+            metadata[:source_url] = source_url if source_url
+            metadata
+          end
+        end
+      end
+    end
+  end
+end