mnenv 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '090048897f563d0162ceda95dd4f727cda725916b40e7150d815280dc9592ef6'
-  data.tar.gz: 0fbf4dfbbff09224c9672fef91b5607289848166bb58eaeb904d6633eecfcfdf
+  metadata.gz: ebbe93f7754277cc8cb84ed21cf9d8c588c8dc9edd2164a51a4e175509e0afc8
+  data.tar.gz: d6c02ff55dbf8dbc816102e603c07a0a5e947b0570cfda4b6d08c0736f5e78da
 SHA512:
-  metadata.gz: 4695512492c103578d75100163c8201407473f73d53c67e1ebf684e7b6f248d29012caf1f17b504e5f1b4167de34199f07b5c04b09e6749fcc0634c7bcc53a8c
-  data.tar.gz: cea3fa81d4e70f8516d5866b5ee144ae8e734deccc09d80a3269d1deb98207f8af9468c82c89ef2e68256f9336d8e607968c9b59116d9f5644ca1c5cdf962c40
+  metadata.gz: 1a6b0db4fb7021a8b82af5532632c39273afe217984487f61e21b1110738a3f2cc04221de9056d18f77b5656264bbaf7224bea5a417e2455ce26a0e8f00d0695
+  data.tar.gz: bd4196df600ebd1fcfcafc5db7baa6dc35dcf5ceafb762a6615e3fde71f3ca4d8de315d00e372b3cf836772c40d6e6c9a784bd27faf5b0aabf325044e8aac2bb

data/lib/mnenv/commands/snap_command.rb

@@ -28,17 +28,9 @@ module Mnenv
     desc 'refresh', 'Fetch and add new Snap versions (incremental)'
     def refresh
       fetcher = Snap::Fetcher.new
-      repo = fetcher.repository
-
-      # Build map of existing composite keys
-      existing_keys = repo.all.map { |v| "#{v.version}-#{v.revision}-#{v.arch}-#{v.channel}" }
+      existing = fetcher.repository.all.map(&:version)
       remote_versions = fetcher.fetch_all
-
-      # Find truly new versions (composite key doesn't exist)
-      new_versions = remote_versions.reject do |v|
-        key = "#{v.version}-#{v.revision}-#{v.arch}-#{v.channel}"
-        existing_keys.include?(key)
-      end
+      new_versions = remote_versions.reject { |v| existing.include?(v.version) }
 
       if new_versions.empty?
         puts 'No new Snap versions found'
@@ -55,22 +47,21 @@ module Mnenv
       puts "Revamped #{versions.size} Snap versions"
     end
 
-    desc 'update VERSION', 'Update a specific Snap version (all arch/channel combinations)'
+    desc 'update VERSION', 'Update a specific Snap version'
     def update(version)
       fetcher = Snap::Fetcher.new
       versions = fetcher.fetch_all
-      targets = versions.select { |v| v.version == version }
+      target = versions.find { |v| v.version == version }
 
-      if targets.empty?
-        puts "Snap version #{version} not found in current channel-map"
-        puts 'Note: Historical versions no longer in Snap API cannot be updated'
+      if target.nil?
+        puts "Snap version #{version} not found"
         exit 1
       end
 
-      fetcher.repository.save_all(targets)
-      puts "Updated #{targets.size} Snap entries for version #{version}:"
-      targets.each do |v|
-        puts "  - #{v.arch}/#{v.channel}: revision #{v.revision}"
+      fetcher.repository.save_all([target])
+      puts "Updated 1 Snap entry for version #{version}:"
+      target.channels.each do |v|
+        puts "  - channel: #{v.name} arch: #{v.arch} revision: #{v.revision}"
       end
     end
 

data/lib/mnenv/commands/uninstall_command.rb

@@ -7,36 +7,105 @@ module Mnenv
   class UninstallCommand < Thor
     namespace :uninstall
 
+    class_option :source, type: :string, enum: %w[gemfile binary],
+                          desc: 'Source type to uninstall (gemfile or binary). If not specified, uninstalls all sources.'
     class_option :force, type: :boolean, aliases: '-f', default: false,
                          desc: 'Force uninstallation without confirmation'
 
     desc 'VERSION', 'Uninstall a specific Metanorma version'
+    method_option :source, type: :string, enum: %w[gemfile binary]
     method_option :force, type: :boolean, aliases: '-f', default: false
     def uninstall(version)
-      version_dir = File.expand_path("~/.mnenv/versions/#{version}")
+      source = options[:source]
+
+      if source
+        # Uninstall specific source
+        uninstall_source(version, source)
+      else
+        # Uninstall all sources for this version
+        uninstall_all_sources(version)
+      end
+
+      # Regenerate shims after uninstallation
+      ShimManager.new.regenerate_all
+    rescue StandardError => e
+      warn "Error: #{e.message}"
+      exit 1
+    end
+
+    private
+
+    def uninstall_source(version, source)
+      version_dir = Paths.version_install_dir(version, source)
 
       unless Dir.exist?(version_dir)
+        puts "Version #{version} (source: #{source}) is not installed."
+        return
+      end
+
+      confirm_and_remove(version, source, version_dir)
+    end
+
+    def uninstall_all_sources(version)
+      # Find all installed sources for this version
+      installed_sources = find_installed_sources(version)
+
+      if installed_sources.empty?
         puts "Version #{version} is not installed."
         return
       end
 
-      unless options[:force]
+      if installed_sources.length == 1
+        # Only one source, uninstall directly
+        source = installed_sources.first
+        version_dir = Paths.version_install_dir(version, source)
+        confirm_and_remove(version, source, version_dir)
+      else
+        # Multiple sources, ask which to uninstall
+        puts "Version #{version} has multiple sources installed:"
+        installed_sources.each do |src|
+          puts "  - #{src}"
+        end
+        puts ''
+
+        prompt = TTY::Prompt.new
+        choices = installed_sources.map { |s| { name: s, value: s } }
+        choices << { name: 'All sources', value: 'all' }
+
+        selected = prompt.select('Which source(s) to uninstall?', choices)
+
+        if selected == 'all'
+          installed_sources.each do |src|
+            version_dir = Paths.version_install_dir(version, src)
+            confirm_and_remove(version, src, version_dir, skip_confirm: options[:force])
+          end
+        else
+          version_dir = Paths.version_install_dir(version, selected)
+          confirm_and_remove(version, selected, version_dir)
+        end
+      end
+    end
+
+    def find_installed_sources(version)
+      sources = []
+      %w[gemfile binary].each do |source|
+        version_dir = Paths.version_install_dir(version, source)
+        sources << source if Dir.exist?(version_dir)
+      end
+      sources
+    end
+
+    def confirm_and_remove(version, source, version_dir, skip_confirm: false)
+      unless skip_confirm || options[:force]
         prompt = TTY::Prompt.new
-        unless prompt.yes?("Uninstall Metanorma #{version}? This cannot be undone.")
+        unless prompt.yes?("Uninstall Metanorma #{version} (#{source})? This cannot be undone.")
           puts 'Uninstallation cancelled.'
           return
         end
       end
 
       FileUtils.rm_rf(version_dir)
-
-      # Regenerate shims
-      ShimManager.new.regenerate_all
-
-      puts "Uninstalled Metanorma #{version}"
-    rescue StandardError => e
-      warn "Error: #{e.message}"
-      exit 1
+      puts "Uninstalled Metanorma #{version} (source: #{source})"
     end
   end
 end

data/lib/mnenv/commands/version_command.rb

@@ -3,7 +3,7 @@
 require 'tty/prompt'
 require 'json'
 require_relative '../installer'
-require_relative '../binary_repository'
+require_relative '../version_resolver'
 
 module Mnenv
   class VersionCommand < Thor
@@ -68,7 +68,7 @@ module Mnenv
         return
       end
 
-      current_version, current_source = resolve_current
+      current_version, current_source = resolver.resolve
 
       case options[:format]
       when 'json'
@@ -105,6 +105,11 @@ module Mnenv
 
     private
 
+    # Get the shared resolver instance
+    def resolver
+      @resolver ||= VersionResolver.new
+    end
+
     # List installed versions with their sources
     # Uses Paths::INSTALLED_DIR with new naming convention: <version>-<source>
     def list_installed_versions
@@ -129,7 +134,7 @@ module Mnenv
 
     def resolve_version_and_source(version, source, interactive)
       version, source = select_version_interactive if interactive || version.nil?
-      source ||= default_source
+      source ||= resolver.resolve_source
       [version, source]
     end
 
@@ -140,14 +145,12 @@ module Mnenv
       raise 'No versions installed. Run: mnenv install --list' if installed.empty?
 
       choices = installed.flat_map do |version, sources|
-        sources.map do |source|
-          { name: "#{version} (#{source})", value: [version, source] }
+        sources.map do |src|
+          { name: "#{version} (#{src})", value: [version, src] }
         end
       end
 
-      version, source = prompt.select('Select a version:', choices)
-
-      [version, source]
+      prompt.select('Select a version:', choices)
     end
 
     def verify_installed!(version, source)
@@ -160,54 +163,5 @@ module Mnenv
     def installed_versions
       list_installed_versions.keys.sort
     end
-
-    def default_source
-      if File.exist?(Paths::SOURCE_FILE)
-        File.read(Paths::SOURCE_FILE).strip
-      else
-        'gemfile'
-      end
-    end
-
-    def resolve_version
-      return ENV['METANORMA_VERSION'] if ENV['METANORMA_VERSION']
-
-      dir = Dir.pwd
-      loop do
-        return File.read(File.join(dir, '.metanorma-version')).strip if File.exist?(File.join(dir,
-                                                                                              '.metanorma-version'))
-
-        parent = File.dirname(dir)
-        break if parent == dir # Reached root
-
-        dir = parent
-      end
-
-      return File.read(Paths::VERSION_FILE).strip if File.exist?(Paths::VERSION_FILE)
-
-      nil
-    end
-
-    def resolve_source
-      return ENV['METANORMA_SOURCE'] if ENV['METANORMA_SOURCE']
-
-      dir = Dir.pwd
-      loop do
-        return File.read(File.join(dir, '.metanorma-source')).strip if File.exist?(File.join(dir, '.metanorma-source'))
-
-        parent = File.dirname(dir)
-        break if parent == dir # Reached root
-
-        dir = parent
-      end
-
-      return File.read(Paths::SOURCE_FILE).strip if File.exist?(Paths::SOURCE_FILE)
-
-      'gemfile'
-    end
-
-    def resolve_current
-      [resolve_version, resolve_source]
-    end
   end
 end

data/lib/mnenv/gemfile/extractor.rb

@@ -80,6 +80,8 @@ module Mnenv
         # Store relative paths (relative to data/gemfile directory)
         version.gemfile_path = "v#{version.version}/Gemfile"
         version.gemfile_lock_path = "v#{version.version}/Gemfile.lock.archived"
+        # Set parsed_at to now if not already set
+        version.parsed_at = DateTime.now if version.parsed_at.nil?
 
         repository.save(version)
       end

data/lib/mnenv/installer/factory.rb

@@ -1,17 +1,46 @@
 # frozen_string_literal: true
 
+require_relative '../source_registry'
+
 module Mnenv
+  # Factory for creating installer instances based on source type
+  # Uses SourceRegistry for extensibility - new sources just need to register
   class InstallerFactory
-    def self.create(version, source:)
-      case source.to_s
-      when 'gemfile'
-        Installers::GemfileInstaller.new(version, source: source)
-      when 'binary'
-        Installers::BinaryInstaller.new(version, source: source)
-      else
+    class UnknownSourceError < StandardError; end
+
+    # Create an installer for the given version and source
+    # @param version [String] The version to install
+    # @param source [String] The source type (e.g., 'gemfile', 'binary')
+    # @param target_dir [String, nil] Optional custom target directory
+    # @return [Installer] An installer instance
+    # @raise [UnknownSourceError] If source is not registered
+    def self.create(version, source:, target_dir: nil)
+      installer_class = SourceRegistry.installer(source.to_s)
+
+      unless installer_class
+        available = SourceRegistry.all_names.join(', ')
         raise Installer::InstallationError,
-              "Unknown source: #{source}. Use: gemfile or binary"
+              "Unknown source: #{source}. Available sources: #{available}"
       end
+
+      installer_class.new(version, source: source, target_dir: target_dir)
+    rescue SourceRegistry::UnknownSourceError
+      available = SourceRegistry.all_names.join(', ')
+      raise Installer::InstallationError,
+            "Unknown source: #{source}. Available sources: #{available}"
+    end
+
+    # Check if a source is supported
+    # @param source [String] The source type
+    # @return [Boolean]
+    def self.supported?(source)
+      SourceRegistry.registered?(source.to_s)
+    end
+
+    # Get list of supported sources
+    # @return [Array<String>]
+    def self.supported_sources
+      SourceRegistry.all_names
     end
   end
 end

data/lib/mnenv/models/snap_channel.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Mnenv
+  class SnapChannel < Lutaml::Model::Serializable
+    attribute :revision, :integer
+    attribute :arch, :string, default: 'amd64'
+    attribute :name, :string, default: 'stable'
+
+    key_value do
+      map 'name', to: :name
+      map 'revision', to: :revision
+      map 'arch', to: :arch
+    end
+
+    def to_hash
+      super.merge(
+        'revision' => revision,
+        'arch' => arch,
+        'name' => name
+      )
+    end
+  end
+end

data/lib/mnenv/models/snap_version.rb

@@ -1,29 +1,20 @@
 # frozen_string_literal: true
 
 require_relative 'version'
+require_relative 'snap_channel'
 
 module Mnenv
   class SnapVersion < ArtifactVersion
-    attribute :revision, :integer
-    attribute :arch, :string, default: 'amd64'
-    attribute :channel, :string, default: 'stable'
+    attribute :channels, ::Mnenv::SnapChannel,
+              collection: true, default: -> { [] }
 
     key_value do
-      map 'version', to: :version
-      map 'published_at', to: :published_at
-      map 'parsed_at', to: :parsed_at
-      map 'revision', to: :revision
-      map 'arch', to: :arch
-      map 'channel', to: :channel
+      map 'channels', to: :channels
     end
 
-    def display_name = revision ? "#{version}-#{revision}" : "v#{version}"
-
     def to_hash
       super.merge(
-        'revision' => revision,
-        'arch' => arch,
-        'channel' => channel
+        'channels' => channels.map(&:to_hash)
       )
     end
   end

data/lib/mnenv/platform_detector.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Mnenv
+  # Centralized platform detection for consistent OS/architecture/variant detection
+  # across the codebase. Used by binary installer, repository, and CLI.
+  class PlatformDetector
+    class UnsupportedPlatform < StandardError; end
+
+    class << self
+      # Detect the current operating system
+      # @return [String] 'linux', 'darwin', or 'windows'
+      # @raise [UnsupportedPlatform] if platform is not supported
+      def os
+        case RbConfig::CONFIG['host_os']
+        when /linux/
+          'linux'
+        when /darwin/
+          'darwin'
+        when /mswin|mingw|cygwin/
+          'windows'
+        else
+          raise UnsupportedPlatform, "Unsupported platform: #{RbConfig::CONFIG['host_os']}"
+        end
+      end
+
+      # Detect the current CPU architecture
+      # @return [String] 'arm64' or 'x86_64'
+      def arch
+        case RbConfig::CONFIG['host_cpu']
+        when /arm64|aarch64/
+          'arm64'
+        when /x86_64|x64/
+          'x86_64'
+        else
+          'x86_64' # Default fallback
+        end
+      end
+
+      # Detect libc variant (for Linux)
+      # @return [String, nil] 'musl' for Alpine/musl systems, nil for glibc
+      def variant
+        return nil unless os == 'linux'
+
+        'musl' if musl?
+      end
+
+      # Check if running on a musl-based system (Alpine Linux)
+      # @return [Boolean]
+      def musl?
+        File.exist?('/etc/alpine-release') ||
+          File.symlink?('/lib/libc.musl-x86_64.so.1')
+      rescue StandardError
+        false
+      end
+
+      # Check if running on Windows
+      # @return [Boolean]
+      def windows?
+        os == 'windows'
+      end
+
+      # Check if running on macOS
+      # @return [Boolean]
+      def macos?
+        os == 'darwin'
+      end
+
+      # Check if running on Linux
+      # @return [Boolean]
+      def linux?
+        os == 'linux'
+      end
+
+      # Get platform info as a hash
+      # @return [Hash] With keys :os, :arch, :variant
+      def to_h
+        {
+          os: os,
+          arch: arch,
+          variant: variant
+        }
+      end
+
+      # Get a human-readable platform string
+      # @return [String] e.g., "linux-x86_64", "darwin-arm64", "linux-musl-x86_64"
+      def platform_string
+        parts = [os]
+        parts << variant if variant
+        parts << arch
+        parts.join('-')
+      end
+
+      # Get all possible platform strings for binary matching
+      # (includes variant-specific and generic versions)
+      # @return [Array<String>] List of platform strings in order of preference
+      def platform_candidates
+        candidates = []
+
+        # With variant (if applicable)
+        candidates << "#{os}-#{variant}-#{arch}" if variant
+
+        # Without variant
+        candidates << "#{os}-#{arch}"
+
+        candidates
+      end
+    end
+  end
+end

data/lib/mnenv/repository.rb

@@ -62,7 +62,7 @@ module Mnenv
       end
     end
 
-    # Override in subclasses for custom caching (e.g., SnapRepository uses composite keys)
+    # Override in subclasses for custom caching
     def cache_version(version)
       @versions_cache[version.version] = version
     end

data/lib/mnenv/snap/fetcher.rb

@@ -8,6 +8,9 @@ require 'uri'
 require 'json'
 require 'fileutils'
 require 'net/http'
+require_relative 'missing_credentials_error'
+require_relative 'snapcraft_not_available_error'
+require_relative 'login_failed_error'
 
 module Mnenv
   module Snap
@@ -24,45 +27,112 @@ module Mnenv
       ARCHITECTURES = %w[amd64 arm64].freeze
 
       def fetch_all
-        # Load existing versions from YAML (single source of truth)
-        existing_map = repository.all.to_h { |v| [snap_key(v), v] }
+        fetch_all_from_snapcraft
+      end
+
+      def fetch_all_from_cache
+        # Load existing versions from YAML
+        version_map = repository.all
 
         # Fetch current heads from snap_metadata API
         current_versions = fetch_current_heads
 
-        # Merge: keep existing, add/update current from API
-        version_map = {}
-
-        # Add all existing versions
-        existing_map.each_value { |v| version_map[snap_key(v)] = v }
-
-        # Add/update current from API (overrides existing if same key)
-        current_versions.each do |cv|
-          key = snap_key_hash(cv)
-          version_map[key] = SnapVersion.new(
-            version: cv.fetch('version'),
-            revision: cv.fetch('revision'),
-            arch: cv.fetch('arch'),
-            channel: cv.fetch('channel')
+        current_versions.each_key do |k|
+          next if repository.exists?(k)
+
+          # Add new version
+          version_map << SnapVersion.new(
+            version: k,
+            parsed_at: DateTime.now,
+            channels: current_versions[k].map do |cv|
+              SnapChannel.new(
+                name: cv.fetch('channel'),
+                revision: cv.fetch('revision'),
+                arch: cv.fetch('arch')
+              )
+            end
           )
         end
 
-        version_map.values.sort
+        version_map
+      end
+
+      def fetch_all_from_snapcraft
+        raise MissingCredentialsError unless ENV['SNAPCRAFT_STORE_CREDENTIALS']
+        raise SnapcraftNotAvailableError unless snapcraft_available?
+
+        login_result = system('echo "$SNAPCRAFT_STORE_CREDENTIALS" | snapcraft login --with -')
+
+        raise LoginFailedError unless login_result
+
+        # delete the environment variable immediately to prevent
+        # duplicate login error
+        ENV.delete('SNAPCRAFT_STORE_CREDENTIALS')
+
+        result = `snapcraft revisions metanorma`
+        snap_revisions = parse_snap_revisions(result)
+        build_snap_version_map(snap_revisions)
       end
 
       private
 
-      def snap_key(version)
-        "#{version.version}-#{version.revision}-#{version.arch}-#{version.channel}"
+      def snapcraft_available?
+        system('command -v snapcraft > /dev/null 2>&1')
       end
 
-      def snap_key_hash(hash)
-        "#{hash.fetch('version')}-#{hash.fetch('revision')}-#{hash.fetch('arch')}-#{hash.fetch('channel')}"
+      def parse_snap_revisions(data)
+        lines = data.lines.map(&:strip).reject { |l| l.empty? || l.start_with?('Rev.') }
+        revisions = []
+        lines.each do |line|
+          fields = line.split(/\s{2,}/)
+          rev, uploaded, arches, version, channels = fields
+          revisions << {
+            version: version,
+            published_at: uploaded,
+            revision: rev,
+            arch: arches,
+            channels: channels
+          }
+        end
+        revisions
+      end
+
+      def build_snap_version_map(snap_revisions)
+        versions = []
+        latest_version = snap_revisions.first[:version]
+
+        snap_revisions.each do |sr|
+          snap_version = versions.find { |v| v&.version == sr[:version] }
+          if snap_version.nil?
+            snap_version = SnapVersion.new
+            snap_version.version = sr[:version]
+            snap_version.published_at = sr[:published_at]
+            snap_version.parsed_at = DateTime.now
+          end
+
+          channels = sr[:channels].split(',').map(&:strip)
+          channels.each do |channel|
+            next unless channel.start_with? 'latest/'
+
+            channel = channel.sub('latest/', '')
+            next if (sr[:version] == latest_version) && !channel.end_with?('*')
+
+            snap_version.channels << SnapChannel.new(
+              name: channel.gsub('*', ''),
+              revision: sr[:revision],
+              arch: sr[:arch]
+            )
+          end
+
+          versions << snap_version
+        end
+
+        versions.reverse
       end
 
       # Fetch current heads from snap_metadata API for all channel/arch combinations
       def fetch_current_heads
-        versions = []
+        versions = {}
 
         CHANNELS.each do |channel|
           ARCHITECTURES.each do |arch|
@@ -88,8 +158,9 @@ module Mnenv
 
             if data['_embedded'] && data['_embedded']['clickindex:package']
               pkg = data['_embedded']['clickindex:package'][0]
-              versions << {
-                'version' => pkg['version'],
+
+              versions[pkg['version']] ||= []
+              versions[pkg['version']] << {
                 'revision' => pkg['revision'],
                 'arch' => arch,
                 'channel' => channel

data/lib/mnenv/snap/login_failed_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Mnenv
+  module Snap
+    class LoginFailedError < StandardError
+      def initialize
+        super('Failed to login to snapcraft with provided credentials.')
+      end
+    end
+  end
+end

data/lib/mnenv/snap/missing_credentials_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Mnenv
+  module Snap
+    class MissingCredentialsError < StandardError
+      def initialize
+        super('Missing SNAPCRAFT_STORE_CREDENTIALS environment variable. Please set it to fetch Snap versions.')
+      end
+    end
+  end
+end

data/lib/mnenv/snap/snapcraft_not_available_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Mnenv
+  module Snap
+    class SnapcraftNotAvailableError < StandardError
+      def initialize
+        super('Snapcraft is not available. Please install Snapcraft to fetch Snap versions.')
+      end
+    end
+  end
+end

data/lib/mnenv/snap_repository.rb

@@ -8,45 +8,30 @@ module Mnenv
     def version_class = SnapVersion
     def source_name = :snap
 
-    # Override cache_version to use composite key for Snap
-    # Since same version can have multiple revisions/arch/channels
-    def cache_version(version)
-      @versions_cache[snap_key(version)] = version
-    end
-
-    # Override find to work with composite keys
-    def find(version_number)
-      @versions_cache.values.find { |v| v.version == version_number }
-    end
-
-    # Find by specific version, revision, arch, channel
-    def find_exact(version_number, revision, arch, channel)
-      @versions_cache[snap_key(version_number, revision, arch, channel)]
-    end
-
-    # Get all entries for a specific version
-    def find_all_by_version(version_number)
-      @versions_cache.values.select { |v| v.version == version_number }.sort
-    end
-
-    def exists?(version_number)
-      @versions_cache.values.any? { |v| v.version == version_number }
-    end
-
-    private
-
-    def snap_key(*args)
-      case args.size
-      when 1
-        # Single SnapVersion object
-        v = args.first
-        "#{v.version}-#{v.revision}-#{v.arch}-#{v.channel}"
-      when 4
-        # version, revision, arch, channel
-        version_number, revision, arch, channel = args
-        "#{version_number}-#{revision}-#{arch}-#{channel}"
-      else
-        raise ArgumentError, 'snap_key requires 1 or 4 arguments'
+    protected
+
+    def load
+      data = fetch_versions_data
+
+      return if data.nil? || data['versions'].nil?
+
+      data['versions'].each do |version_hash|
+        channels = version_hash['channels'].map do |c|
+          SnapChannel.new(
+            name: c['name'],
+            revision: c['revision'],
+            arch: c['arch']
+          )
+        end
+
+        version = SnapVersion.new.tap do |v|
+          v.version = version_hash['version']
+          v.published_at = version_hash['published_at']
+          v.parsed_at = version_hash['parsed_at']
+          v.channels = channels
+        end
+
+        cache_version(version)
       end
     end
   end

data/lib/mnenv/sources.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'source_registry'
+require_relative 'gemfile_repository'
+require_relative 'binary_repository'
+require_relative 'models/gemfile_version'
+require_relative 'models/binary_version'
+require_relative 'installers/gemfile_installer'
+require_relative 'installers/binary_installer'
+
+module Mnenv
+  # Auto-registration of built-in sources
+  # This enables the plugin architecture - new sources just need to register themselves
+  module Sources
+    class << self
+      # Register all built-in sources
+      def setup
+        register_gemfile
+        register_binary
+      end
+
+      private
+
+      def register_gemfile
+        SourceRegistry.register(
+          name: 'gemfile',
+          repository: GemfileRepository,
+          model: GemfileVersion,
+          installer: Installers::GemfileInstaller
+        )
+      end
+
+      def register_binary
+        SourceRegistry.register(
+          name: 'binary',
+          repository: BinaryRepository,
+          model: BinaryVersion,
+          installer: Installers::BinaryInstaller
+        )
+      end
+    end
+  end
+end
+
+# Auto-setup on load
+Mnenv::Sources.setup

data/lib/mnenv/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mnenv
-  VERSION = '0.1.1'
+  VERSION = '0.1.3'
 end

data/lib/mnenv/version_resolver.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Mnenv
+  # Centralized version and source resolution with clear precedence:
+  # 1. Environment variables (METANORMA_VERSION, METANORMA_SOURCE)
+  # 2. Local files (.metanorma-version, .metanorma-source) - walk up tree
+  # 3. Global files (~/.mnenv/version, ~/.mnenv/source)
+  # 4. Defaults (gemfile for source)
+  #
+  # This class is the single source of truth for version resolution.
+  # The Bash resolver (lib/mnenv/resolver) is kept for shims only.
+  class VersionResolver
+    # Resolve the current Metanorma version
+    # @return [String, nil] The resolved version or nil if not set
+    def resolve_version
+      from_env('METANORMA_VERSION') ||
+        from_local_file('.metanorma-version') ||
+        from_global_file(Paths::VERSION_FILE)
+    end
+
+    # Resolve the current Metanorma source
+    # @return [String] The resolved source (defaults to 'gemfile')
+    def resolve_source
+      from_env('METANORMA_SOURCE') ||
+        from_local_file('.metanorma-source') ||
+        from_global_file(Paths::SOURCE_FILE) ||
+        'gemfile'
+    end
+
+    # Resolve both version and source
+    # @return [Array<String, String>] Tuple of [version, source]
+    def resolve
+      [resolve_version, resolve_source]
+    end
+
+    # Check if a version is set anywhere
+    # @return [Boolean]
+    def version_set?
+      !resolve_version.nil?
+    end
+
+    # Check if a source is explicitly set (not default)
+    # @return [Boolean]
+    def source_set?
+      from_env('METANORMA_SOURCE') ||
+        from_local_file('.metanorma-source') ||
+        from_global_file(Paths::SOURCE_FILE)
+    end
+
+    # Get the source of version resolution (for debugging)
+    # @return [Symbol] :environment, :local, :global, or :none
+    def version_source
+      return :environment if from_env('METANORMA_VERSION')
+      return :local if from_local_file('.metanorma-version')
+      return :global if from_global_file(Paths::VERSION_FILE)
+
+      :none
+    end
+
+    # Get the source of source resolution (for debugging)
+    # @return [Symbol] :environment, :local, :global, or :default
+    def source_source
+      return :environment if from_env('METANORMA_SOURCE')
+      return :local if from_local_file('.metanorma-source')
+      return :global if from_global_file(Paths::SOURCE_FILE)
+
+      :default
+    end
+
+    private
+
+    # Read from environment variable
+    # @param var [String] Environment variable name
+    # @return [String, nil] Value or nil if not set/empty
+    def from_env(var)
+      value = ENV[var]
+      value&.strip&.then { |v| v unless v.empty? }
+    end
+
+    # Read from local file, walking up directory tree
+    # @param filename [String] Filename to look for
+    # @return [String, nil] File contents or nil if not found
+    def from_local_file(filename)
+      dir = Dir.pwd
+
+      loop do
+        path = File.join(dir, filename)
+        return File.read(path).strip if File.exist?(path)
+
+        parent = File.dirname(dir)
+        break if parent == dir # Reached root
+
+        dir = parent
+      end
+
+      nil
+    end
+
+    # Read from global file
+    # @param path [String] Full path to file
+    # @return [String, nil] File contents or nil if not found
+    def from_global_file(path)
+      File.read(path).strip if File.exist?(path)
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/mnenv.rb

@@ -4,8 +4,11 @@ require 'lutaml/model'
 require 'thor'
 
 require_relative 'mnenv/paths'
+require_relative 'mnenv/platform_detector'
+require_relative 'mnenv/version_resolver'
 require_relative 'mnenv/models'
+require_relative 'mnenv/source_registry'
+require_relative 'mnenv/sources'
 require_relative 'mnenv/commands'
 require_relative 'mnenv/installer'
-require_relative 'mnenv/source_registry'
 require_relative 'mnenv/cli'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mnenv
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-14 00:00:00.000000000 Z
+date: 2026-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -206,9 +206,11 @@ files:
 - lib/mnenv/models/chocolatey_version.rb
 - lib/mnenv/models/gemfile_version.rb
 - lib/mnenv/models/homebrew_version.rb
+- lib/mnenv/models/snap_channel.rb
 - lib/mnenv/models/snap_version.rb
 - lib/mnenv/models/version.rb
 - lib/mnenv/paths.rb
+- lib/mnenv/platform_detector.rb
 - lib/mnenv/repository.rb
 - lib/mnenv/resolver
 - lib/mnenv/shells/base.rb
@@ -219,9 +221,14 @@ files:
 - lib/mnenv/shim_manager.rb
 - lib/mnenv/snap.rb
 - lib/mnenv/snap/fetcher.rb
+- lib/mnenv/snap/login_failed_error.rb
+- lib/mnenv/snap/missing_credentials_error.rb
+- lib/mnenv/snap/snapcraft_not_available_error.rb
 - lib/mnenv/snap_repository.rb
 - lib/mnenv/source_registry.rb
+- lib/mnenv/sources.rb
 - lib/mnenv/version.rb
+- lib/mnenv/version_resolver.rb
 - lib/mnenv/versions_manager.rb
 - mnenv.gemspec
 - scripts/cross-source-switching-test.sh