factorix 0.5.0

data/sig/factorix/dependency/edge.rbs

@@ -0,0 +1,32 @@
+# RBS type signature file
+# NOTE: Do not include private method definitions in RBS files.
+#       Only public interfaces should be documented here.
+
+module Factorix
+  module Dependency
+    class Edge
+      REQUIRED: Symbol
+      OPTIONAL: Symbol
+      HIDDEN_OPTIONAL: Symbol
+      INCOMPATIBLE: Symbol
+      LOAD_NEUTRAL: Symbol
+
+      attr_reader from_mod: MOD
+      attr_reader to_mod: MOD
+      attr_reader type: Symbol
+      attr_reader version_requirement: MODVersionRequirement?
+
+      def initialize: (from_mod: MOD, to_mod: MOD, type: Symbol, ?version_requirement: MODVersionRequirement?) -> void
+
+      def required?: () -> bool
+      def optional?: () -> bool
+      def incompatible?: () -> bool
+      def load_neutral?: () -> bool
+
+      def satisfied_by?: (MODVersion version) -> bool
+
+      def to_s: () -> String
+      def inspect: () -> String
+    end
+  end
+end

data/sig/factorix/dependency/entry.rbs

@@ -0,0 +1,30 @@
+# RBS type signature file
+# NOTE: Do not include private method definitions in RBS files.
+#       Only public interfaces should be documented here.
+
+module Factorix
+  module Dependency
+    class Entry
+      REQUIRED: Symbol
+      OPTIONAL: Symbol
+      HIDDEN_OPTIONAL: Symbol
+      INCOMPATIBLE: Symbol
+      LOAD_NEUTRAL: Symbol
+
+      attr_reader mod: MOD
+      attr_reader type: Symbol
+      attr_reader version_requirement: MODVersionRequirement?
+
+      def initialize: (mod: MOD, type: Symbol, ?version_requirement: MODVersionRequirement?) -> void
+
+      def required?: () -> bool
+      def optional?: () -> bool
+      def incompatible?: () -> bool
+      def load_neutral?: () -> bool
+
+      def satisfied_by?: (MODVersion version) -> bool
+
+      def to_s: () -> String
+    end
+  end
+end

data/sig/factorix/dependency/graph/builder.rbs

@@ -0,0 +1,17 @@
+# RBS type signature file
+# NOTE: Do not include private method definitions in RBS files.
+#       Only public interfaces should be documented here.
+
+module Factorix
+  module Dependency
+    class Graph
+      class Builder
+        def self.build: (installed_mods: Array[InstalledMOD], mod_list: MODList) -> Graph
+
+        def initialize: (installed_mods: Array[InstalledMOD], mod_list: MODList) -> void
+
+        def build: () -> Graph
+      end
+    end
+  end
+end

data/sig/factorix/dependency/graph.rbs

@@ -0,0 +1,39 @@
+# RBS type signature file
+# NOTE: Do not include private method definitions in RBS files.
+#       Only public interfaces should be documented here.
+
+module Factorix
+  module Dependency
+    class Graph
+      def initialize: () -> void
+
+      def add_node: (Node node) -> void
+      def set_node_operation: (MOD mod, Symbol? operation) -> Node?
+      def add_edge: (Edge edge) -> void
+      def add_uninstalled_mod: (API::MODInfo mod_info, API::Release release, ?operation: Symbol) -> void
+
+      def node: (MOD mod) -> Node?
+      def nodes: () -> Array[Node]
+
+      def edges_from: (MOD mod) -> Array[Edge]
+      def edges_to: (MOD mod) -> Array[Edge]
+      def find_enabled_dependents: (MOD mod) -> Array[MOD]
+      def edges: () -> Array[Edge]
+
+      def node?: (MOD mod) -> bool
+
+      def size: () -> Integer
+      def empty?: () -> bool
+
+      def topological_order: () -> Array[MOD]
+      def cyclic?: () -> bool
+      def strongly_connected_components: () -> Array[Array[MOD]]
+
+      def tsort_each_node: () { (MOD) -> void } -> void
+      def tsort_each_child: (MOD mod) { (MOD) -> void } -> void
+
+      def to_s: () -> String
+      def inspect: () -> String
+    end
+  end
+end

data/sig/factorix/dependency/list.rbs

@@ -0,0 +1,69 @@
+# RBS type signature file
+# NOTE: Do not include private method definitions in RBS files.
+#       Only public interfaces should be documented here.
+
+module Factorix
+  module Dependency
+    # Represents a collection of MOD dependencies
+    class List
+      include Enumerable[Entry]
+
+      @dependencies: Array[Entry]
+
+      # Create List from an array of dependency strings
+      def self.from_strings: (Array[String] dependency_strings) -> List
+
+      # Initialize a List collection
+      def initialize: (?Array[Entry] dependencies) -> void
+
+      # Iterate through all dependencies
+      def each: () { (Entry) -> void } -> List
+              | () -> Enumerator[Entry, void]
+
+      # Get all required dependencies
+      def required: () -> Array[Entry]
+
+      # Get all optional dependencies (including hidden optional)
+      def optional: () -> Array[Entry]
+
+      # Get all incompatible dependencies
+      def incompatible: () -> Array[Entry]
+
+      # Get all load-neutral dependencies
+      def load_neutral: () -> Array[Entry]
+
+      # Check if this collection depends on a specific MOD
+      def depends_on?: (String | MOD mod_name_or_mod) -> bool
+
+      # Check if this collection marks a MOD as incompatible
+      def incompatible_with?: (String | MOD mod_name_or_mod) -> bool
+
+      # Check if the collection is empty
+      def empty?: () -> bool
+
+      # Get the total number of dependencies
+      def size: () -> Integer
+
+      # Check if all required dependencies are satisfied
+      def satisfied_by?: (Hash[String, MODVersion] available_mods) -> bool
+
+      # Get list of incompatible MODs that are present
+      def conflicts_with?: (Hash[String, MODVersion] available_mods) -> Array[String]
+
+      # Get list of missing required dependencies
+      def missing_required: (Hash[String, MODVersion] available_mods) -> Array[String]
+
+      # Get list of dependencies with unsatisfied version requirements
+      def unsatisfied_versions: (Hash[String, MODVersion] available_mods) -> Hash[String, Hash[Symbol, String]]
+
+      # Detect circular dependencies in a collection of MOD dependencies
+      def self.detect_circular: (Hash[String, List] mod_dependencies_map) -> Array[Array[String]]
+
+      # Convert to array of dependency strings
+      def to_a: () -> Array[String]
+
+      # Convert to hash keyed by MOD name
+      def to_h: () -> Hash[String, Entry]
+    end
+  end
+end

data/sig/factorix/dependency/mod_version_requirement.rbs

@@ -0,0 +1,18 @@
+# RBS type signature file
+# NOTE: Do not include private method definitions in RBS files.
+#       Only public interfaces should be documented here.
+
+module Factorix
+  module Dependency
+    class MODVersionRequirement
+      attr_reader operator: String
+      attr_reader version: MODVersion
+
+      def initialize: (operator: String, version: MODVersion) -> void
+
+      def satisfied_by?: (MODVersion mod_version) -> bool
+
+      def to_s: () -> String
+    end
+  end
+end

data/sig/factorix/dependency/node.rbs

@@ -0,0 +1,24 @@
+# RBS type signature file
+# NOTE: Do not include private method definitions in RBS files.
+#       Only public interfaces should be documented here.
+
+module Factorix
+  module Dependency
+    class Node
+      attr_reader mod: MOD
+      attr_reader version: MODVersion
+      attr_accessor enabled: bool
+      attr_accessor installed: bool
+      attr_accessor operation: Symbol?
+
+      def initialize: (mod: MOD, version: MODVersion, ?enabled: bool, ?installed: bool, ?operation: Symbol?) -> void
+
+      def enabled?: () -> bool
+      def installed?: () -> bool
+      def operation?: () -> bool
+
+      def to_s: () -> String
+      def inspect: () -> String
+    end
+  end
+end

data/sig/factorix/dependency/parser.rbs

@@ -0,0 +1,11 @@
+# RBS type signature file
+# NOTE: Do not include private method definitions in RBS files.
+#       Only public interfaces should be documented here.
+
+module Factorix
+  module Dependency
+    class Parser
+      def parse: (String dependency_string) -> Entry
+    end
+  end
+end

data/sig/factorix/dependency/validation_result.rbs

@@ -0,0 +1,56 @@
+# RBS type signature file
+# NOTE: Do not include private method definitions in RBS files.
+#       Only public interfaces should be documented here.
+
+module Factorix
+  module Dependency
+    class ValidationResult
+      class Error
+        attr_reader type: Symbol
+        attr_reader message: String
+        attr_reader mod: MOD?
+        attr_reader dependency: MOD?
+
+        def initialize: (type: Symbol, message: String, ?mod: MOD?, ?dependency: MOD?) -> void
+      end
+
+      class Warning
+        attr_reader type: Symbol
+        attr_reader message: String
+        attr_reader mod: MOD?
+
+        def initialize: (type: Symbol, message: String, ?mod: MOD?) -> void
+      end
+
+      class Suggestion
+        attr_reader message: String
+        attr_reader mod: MOD
+        attr_reader version: MODVersion
+
+        def initialize: (message: String, mod: MOD, version: MODVersion) -> void
+      end
+
+      MISSING_DEPENDENCY: Symbol
+      DISABLED_DEPENDENCY: Symbol
+      VERSION_MISMATCH: Symbol
+      CONFLICT: Symbol
+      CIRCULAR_DEPENDENCY: Symbol
+
+      MOD_IN_LIST_NOT_INSTALLED: Symbol
+      MOD_INSTALLED_NOT_IN_LIST: Symbol
+
+      attr_reader errors: Array[Error]
+      attr_reader warnings: Array[Warning]
+      attr_reader suggestions: Array[Suggestion]
+
+      def initialize: () -> void
+      def add_error: (type: Symbol, message: String, ?mod: MOD?, ?dependency: MOD?) -> void
+      def add_warning: (type: Symbol, message: String, ?mod: MOD?) -> void
+      def add_suggestion: (message: String, mod: MOD, version: MODVersion) -> void
+      def errors?: () -> bool
+      def warnings?: () -> bool
+      def suggestions?: () -> bool
+      def valid?: () -> bool
+    end
+  end
+end

data/sig/factorix/dependency/validator.rbs

@@ -0,0 +1,13 @@
+# RBS type signature file
+# NOTE: Do not include private method definitions in RBS files.
+#       Only public interfaces should be documented here.
+
+module Factorix
+  module Dependency
+    class Validator
+      def initialize: (graph: Graph, mod_list: MODList, installed_mods: Array[InstalledMOD]) -> void
+
+      def validate: () -> ValidationResult
+    end
+  end
+end

data/sig/factorix/errors.rbs

@@ -0,0 +1,132 @@
+# RBS type signature file
+# NOTE: Do not include private method definitions in RBS files.
+#       Only public interfaces should be documented here.
+
+module Factorix
+  class Error < StandardError
+  end
+
+  # =====================================
+  # Infrastructure layer errors
+  # =====================================
+  class InfrastructureError < Error
+  end
+
+  class ConfigurationError < InfrastructureError
+  end
+
+  class CredentialError < ConfigurationError
+  end
+
+  class ShellError < ConfigurationError
+  end
+
+  class DirectoryNotFoundError < ConfigurationError
+  end
+
+  class URLError < InfrastructureError
+  end
+
+  class PlatformError < InfrastructureError
+  end
+
+  class UnsupportedPlatformError < PlatformError
+  end
+
+  class HTTPError < InfrastructureError
+  end
+
+  class HTTPClientError < HTTPError
+    attr_reader api_error: String?
+    attr_reader api_message: String?
+
+    def initialize: (?String? message, ?api_error: String?, ?api_message: String?) -> void
+  end
+
+  class HTTPNotFoundError < HTTPClientError
+  end
+
+  class HTTPServerError < HTTPError
+  end
+
+  class DigestMismatchError < InfrastructureError
+  end
+
+  class CommandNotFoundError < InfrastructureError
+  end
+
+  class FileFormatError < InfrastructureError
+  end
+
+  class BinaryFormatError < FileFormatError
+  end
+
+  class InvalidLengthError < BinaryFormatError
+  end
+
+  class UnknownPropertyType < BinaryFormatError
+  end
+
+  class ExtraDataError < BinaryFormatError
+  end
+
+  class MODSectionNotFoundError < FileFormatError
+  end
+
+  # =====================================
+  # Domain layer errors
+  # =====================================
+  class DomainError < Error
+  end
+
+  class MODNotFoundError < DomainError
+  end
+
+  class MODNotOnPortalError < MODNotFoundError
+  end
+
+  class BundledMODError < DomainError
+  end
+
+  class MODConflictError < DomainError
+  end
+
+  class MODSettingsError < DomainError
+  end
+
+  class InvalidOperationError < DomainError
+  end
+
+  class InvalidArgumentError < DomainError
+  end
+
+  class VersionParseError < DomainError
+  end
+
+  class DependencyParseError < DomainError
+  end
+
+  class DependencyGraphError < DomainError
+  end
+
+  class DependencyError < DomainError
+  end
+
+  class CircularDependencyError < DependencyError
+  end
+
+  class DependencyMissingError < DependencyError
+  end
+
+  class DependencyVersionError < DependencyError
+  end
+
+  class DependencyViolationError < DependencyError
+  end
+
+  class ValidationError < DomainError
+  end
+
+  class GameRunningError < DomainError
+  end
+end

data/sig/factorix/formatting.rbs

@@ -0,0 +1,8 @@
+# RBS type signature file
+
+module Factorix
+  module Formatting
+    def format_size: (Integer? size) -> String
+    def format_duration: (Integer | Float | nil seconds) -> String
+  end
+end

data/sig/factorix/game_version.rbs

@@ -0,0 +1,24 @@
+# RBS type signature file
+# NOTE: Do not include private method definitions in RBS files.
+#       Only public interfaces should be documented here.
+
+module Factorix
+  class GameVersion
+    include Comparable
+
+    attr_reader major: Integer
+    attr_reader minor: Integer
+    attr_reader patch: Integer
+    attr_reader build: Integer
+
+    def self.from_string: (String str) -> GameVersion
+
+    def self.from_numbers: (Integer major, Integer minor, Integer patch, ?Integer build) -> GameVersion
+
+    def to_s: () -> String
+
+    def to_a: () -> Array[Integer]
+
+    def <=>: (GameVersion other) -> Integer?
+  end
+end

data/sig/factorix/http/cache_decorator.rbs

@@ -0,0 +1,64 @@
+# RBS type signature file
+# NOTE: Do not include private method definitions in RBS files.
+#       Only public interfaces should be documented here.
+
+module Factorix
+  module HTTP
+    # Adds caching for GET requests
+    #
+    # Stores successful GET responses in FileSystem cache.
+    # Only caches non-streaming requests (no block given).
+    class CacheDecorator
+      attr_reader client: Client
+      attr_reader cache: Cache::FileSystem
+      attr_reader logger: Dry::Logger::Dispatcher
+
+      # Execute an HTTP request (only caches GET without block)
+      #
+      # @param method [Symbol] HTTP method
+      # @param uri [URI::HTTPS] target URI
+      # @param headers [Hash<String, String>] request headers
+      # @param body [String, IO, nil] request body
+      # @yield [Net::HTTPResponse] for streaming responses
+      # @return [Response, Object] response object or parsed data
+      def request: (Symbol method, URI::HTTPS uri, ?headers: Hash[String, String], ?body: String | IO | nil) ?{ (Net::HTTPResponse) -> void } -> (Response | CachedResponse)
+
+      # Execute a GET request with caching
+      #
+      # @param uri [URI::HTTPS] target URI
+      # @param headers [Hash<String, String>] request headers
+      # @yield [Net::HTTPResponse] for streaming responses
+      # @return [Response, Object] response object or parsed data
+      def get: (URI::HTTPS uri, ?headers: Hash[String, String]) ?{ (Net::HTTPResponse) -> void } -> (Response | CachedResponse)
+
+      # Execute a POST request (never cached)
+      #
+      # @param uri [URI::HTTPS] target URI
+      # @param body [String, IO] request body
+      # @param headers [Hash<String, String>] request headers
+      # @param content_type [String, nil] Content-Type header
+      # @return [Response] response object
+      def post: (URI::HTTPS uri, body: String | IO, ?headers: Hash[String, String], ?content_type: String?) -> Response
+    end
+
+    # Response wrapper for cached data
+    class CachedResponse
+      attr_reader body: String
+      attr_reader code: Integer
+      attr_reader headers: Hash[String, Array[String]]
+
+      # @param body [String] cached response body
+      def initialize: (String body) -> void
+
+      # Always returns true for cached responses
+      #
+      # @return [Boolean] true
+      def success?: () -> true
+
+      # Get content length from body size
+      #
+      # @return [Integer] body size in bytes
+      def content_length: () -> Integer
+    end
+  end
+end

data/sig/factorix/http/client.rbs

@@ -0,0 +1,55 @@
+# RBS type signature file
+# NOTE: Do not include private method definitions in RBS files.
+#       Only public interfaces should be documented here.
+
+module Factorix
+  module HTTP
+    # Low-level HTTP client using Net::HTTP
+    #
+    # Responsibilities:
+    # - Create and configure Net::HTTP instances
+    # - Execute HTTP methods (GET, POST)
+    # - Handle redirects (up to MAX_REDIRECTS)
+    # - Parse response codes and raise appropriate errors
+    # - Stream reading/writing for large files
+    #
+    # Does NOT handle:
+    # - Retry logic (delegated to RetryDecorator)
+    # - Progress events (delegated to EventDecorator)
+    # - Caching (delegated to CacheDecorator)
+    # - JSON parsing (handled by API clients)
+    class Client
+      attr_reader logger: Dry::Logger::Dispatcher
+      attr_reader masked_params: Array[String]
+
+      def initialize: (?masked_params: Array[String]) -> void
+
+      # Execute an HTTP request
+      #
+      # @param method [Symbol] HTTP method (:get, :post, :put, :delete)
+      # @param uri [URI::HTTPS] target URI
+      # @param headers [Hash<String, String>] request headers
+      # @param body [String, IO, nil] request body
+      # @yield [Net::HTTPResponse] for streaming responses
+      # @return [Response] response object
+      def request: (Symbol method, URI::HTTPS uri, ?headers: Hash[String, String], ?body: String | IO | nil) ?{ (Net::HTTPResponse) -> void } -> Response
+
+      # Execute a GET request
+      #
+      # @param uri [URI::HTTPS] target URI
+      # @param headers [Hash<String, String>] request headers
+      # @yield [Net::HTTPResponse] for streaming responses
+      # @return [Response] response object
+      def get: (URI::HTTPS uri, ?headers: Hash[String, String]) ?{ (Net::HTTPResponse) -> void } -> Response
+
+      # Execute a POST request
+      #
+      # @param uri [URI::HTTPS] target URI
+      # @param body [String, IO] request body
+      # @param headers [Hash<String, String>] request headers
+      # @param content_type [String, nil] Content-Type header
+      # @return [Response] response object
+      def post: (URI::HTTPS uri, body: String | IO, ?headers: Hash[String, String], ?content_type: String?) -> Response
+    end
+  end
+end

data/sig/factorix/http/response.rbs

@@ -0,0 +1,28 @@
+# RBS type signature file
+# NOTE: Do not include private method definitions in RBS files.
+#       Only public interfaces should be documented here.
+
+module Factorix
+  module HTTP
+    # Simple response wrapper for Net::HTTP responses
+    class Response
+      attr_reader code: Integer
+      attr_reader body: String
+      attr_reader headers: Hash[String, Array[String]]
+      attr_reader raw_response: Net::HTTPResponse
+
+      # @param net_http_response [Net::HTTPResponse] Raw Net::HTTP response
+      def initialize: (Net::HTTPResponse net_http_response) -> void
+
+      # Check if response is successful (2xx)
+      #
+      # @return [Boolean] true if 2xx response
+      def success?: () -> bool
+
+      # Get Content-Length from headers
+      #
+      # @return [Integer, nil] content length in bytes, or nil if not present
+      def content_length: () -> Integer?
+    end
+  end
+end

data/sig/factorix/http/retry_decorator.rbs

@@ -0,0 +1,44 @@
+# RBS type signature file
+# NOTE: Do not include private method definitions in RBS files.
+#       Only public interfaces should be documented here.
+
+module Factorix
+  module HTTP
+    # Decorator that adds retry functionality to an HTTP client
+    #
+    # Automatically retries transient errors (timeouts, connection issues)
+    # using an exponential backoff strategy with randomization.
+    class RetryDecorator
+      attr_reader client: Client
+      attr_reader retry_strategy: RetryStrategy
+      attr_reader logger: Dry::Logger::Dispatcher
+
+      # Execute an HTTP request with retry logic
+      #
+      # @param method [Symbol] HTTP method
+      # @param uri [URI::HTTPS] target URI
+      # @param headers [Hash<String, String>] request headers
+      # @param body [String, IO, nil] request body
+      # @yield [Net::HTTPResponse] for streaming responses
+      # @return [Response] response object
+      def request: (Symbol method, URI::HTTPS uri, ?headers: Hash[String, String], ?body: String | IO | nil) ?{ (Net::HTTPResponse) -> void } -> Response
+
+      # Execute a GET request with retry logic
+      #
+      # @param uri [URI::HTTPS] target URI
+      # @param headers [Hash<String, String>] request headers
+      # @yield [Net::HTTPResponse] for streaming responses
+      # @return [Response] response object
+      def get: (URI::HTTPS uri, ?headers: Hash[String, String]) ?{ (Net::HTTPResponse) -> void } -> Response
+
+      # Execute a POST request with retry logic
+      #
+      # @param uri [URI::HTTPS] target URI
+      # @param body [String, IO] request body
+      # @param headers [Hash<String, String>] request headers
+      # @param content_type [String, nil] Content-Type header
+      # @return [Response] response object
+      def post: (URI::HTTPS uri, body: String | IO, ?headers: Hash[String, String], ?content_type: String?) -> Response
+    end
+  end
+end