mnenv 0.1.0

data/lib/mnenv/homebrew/fetcher.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative '../fetcher'
+require_relative '../homebrew_repository'
+require_relative '../models/homebrew_version'
+
+module Mnenv
+  module Homebrew
+    class Fetcher < Mnenv::Fetcher
+      GITHUB_REPO = 'metanorma/homebrew-metanorma'
+      API_URL = "https://api.github.com/repos/#{GITHUB_REPO}/tags".freeze
+
+      def fetch_all
+        uri = URI("#{API_URL}?per_page=100")
+        versions = []
+        page = 0
+
+        loop do
+          data = fetch_json(uri)
+          data.each do |tag|
+            name = tag['name']
+            next unless name.match?(/^v\d+\.\d+\.\d+$/)
+
+            versions << HomebrewVersion.new(
+              version: name.sub(/^v/, ''),
+              tag_name: name,
+              commit_sha: tag['commit']['sha']
+            )
+          end
+
+          page += 1
+          uri = URI("#{API_URL}?per_page=100&page=#{page}")
+          break if data.empty?
+        end
+
+        versions.sort
+      end
+
+      private
+
+      def default_repository = @default_repository ||= HomebrewRepository.new
+    end
+  end
+end

data/lib/mnenv/homebrew_repository.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'repository'
+require_relative 'models/homebrew_version'
+
+module Mnenv
+  class HomebrewRepository < Repository
+    def version_class = HomebrewVersion
+    def source_name = :homebrew
+  end
+end

data/lib/mnenv/json_formatter.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Mnenv
+  class JsonFormatter
+    def self.format_version(version)
+      {
+        'version' => version.version,
+        'published_at' => format_timestamp(version.published_at),
+        'parsed_at' => format_timestamp(version.parsed_at),
+        'display_name' => version.display_name
+      }.merge(version_specific_fields(version))
+    end
+
+    def self.format_versions(versions)
+      {
+        'count' => versions.size,
+        'latest' => versions.last&.version,
+        'versions' => versions.map { |v| format_version(v) }
+      }
+    end
+
+    class << self
+      def format_timestamp(t) = t&.strftime('%Y-%m-%dT%H:%M:%SZ')
+
+      def version_specific_fields(version)
+        case version
+        when GemfileVersion
+          { 'gemfile_exists' => version.exists_locally? }
+        when SnapVersion
+          { 'revision' => version.revision, 'channel' => version.channel }
+        when HomebrewVersion
+          { 'tag_name' => version.tag_name, 'commit_sha' => version.commit_sha }
+        when ChocolateyVersion
+          { 'package_name' => version.package_name, 'is_pre_release' => version.is_pre_release }
+        else
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/mnenv/logger.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'paint'
+
+module Mnenv
+  class Logger
+    # Emojis for different log levels
+    EMOJIS = {
+      info: 'ℹ️',
+      success: '✅',
+      warning: '⚠️',
+      error: '❌',
+      pulling: '📥',
+      extracting: '📦',
+      skipping: '⏭️',
+      cleaning: '🧹'
+    }.freeze
+
+    class << self
+      def info(message)
+        puts Paint["#{EMOJIS[:info]} #{message}", :cyan]
+      end
+
+      def success(message)
+        puts Paint["#{EMOJIS[:success]} #{message}", :green]
+      end
+
+      def warning(message)
+        warn Paint["#{EMOJIS[:warning]} WARNING: #{message}", :yellow]
+      end
+
+      def error(message)
+        warn Paint["#{EMOJIS[:error]} ERROR: #{message}", :red, :bold]
+      end
+
+      def pulling(version)
+        puts Paint["#{EMOJIS[:pulling]} Pulling metanorma/metanorma:#{version}...", :blue]
+      end
+
+      def extracted(version, from: nil)
+        message = "  #{EMOJIS[:extracting]} Extracted to v#{version}/"
+        message += " (from #{from})" if from
+        puts Paint[message, :green]
+      end
+
+      def skipping(version)
+        puts Paint["  #{EMOJIS[:skipping]} Skipping v#{version}/ (already exists)", :yellow]
+      end
+
+      def header(message)
+        puts "\n" + Paint["=== #{message} ===", :bold, :white] + "\n"
+      end
+
+      def section(message)
+        puts Paint["▸ #{message}", :cyan]
+      end
+
+      def sub(message)
+        puts Paint["  • #{message}", :gray]
+      end
+    end
+  end
+end

data/lib/mnenv/models/chocolatey_version.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'version'
+
+module Mnenv
+  class ChocolateyVersion < ArtifactVersion
+    attribute :package_name, :string, default: 'metanorma'
+    attribute :is_pre_release, :boolean, default: false
+
+    key_value do
+      map 'version', to: :version
+      map 'published_at', to: :published_at
+      map 'parsed_at', to: :parsed_at
+      map 'package_name', to: :package_name
+      map 'is_pre_release', to: :is_pre_release
+    end
+  end
+end

data/lib/mnenv/models/gemfile_version.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'version'
+
+module Mnenv
+  class GemfileVersion < ArtifactVersion
+    attribute :gemfile_exists, :boolean, default: false
+    attribute :gemfile_path, :string
+    attribute :gemfile_lock_path, :string
+
+    key_value do
+      map 'version', to: :version
+      map 'published_at', to: :published_at
+      map 'parsed_at', to: :parsed_at
+      map 'gemfile_exists', to: :gemfile_exists
+      map 'gemfile_path', to: :gemfile_path
+      map 'gemfile_lock_path', to: :gemfile_lock_path
+    end
+
+    def data_dir = @data_dir ||= default_data_dir
+
+    def directory_path = File.join(data_dir, "v#{version}")
+
+    def gemfile_path_calc = File.join(directory_path, 'Gemfile')
+
+    def gemfile_lock_path_calc = File.join(directory_path, 'Gemfile.lock.archived')
+
+    def exists_locally?
+      File.directory?(directory_path) &&
+        File.file?(gemfile_path_calc) &&
+        File.file?(gemfile_lock_path_calc)
+    end
+
+    private
+
+    def default_data_dir
+      @default_data_dir ||= File.join(__dir__, '..', '..', '..', 'data', 'gemfile')
+    end
+  end
+end

data/lib/mnenv/models/homebrew_version.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'version'
+
+module Mnenv
+  class HomebrewVersion < ArtifactVersion
+    attribute :tag_name, :string
+    attribute :commit_sha, :string
+
+    key_value do
+      map 'version', to: :version
+      map 'published_at', to: :published_at
+      map 'parsed_at', to: :parsed_at
+      map 'tag_name', to: :tag_name
+      map 'commit_sha', to: :commit_sha
+    end
+
+    def initialize(*args)
+      super
+      @tag_name ||= "v#{version}" if version
+    end
+  end
+end

data/lib/mnenv/models/snap_version.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'version'
+
+module Mnenv
+  class SnapVersion < ArtifactVersion
+    attribute :revision, :integer
+    attribute :arch, :string, default: 'amd64'
+    attribute :channel, :string, default: 'stable'
+
+    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
+    end
+
+    def display_name = revision ? "#{version}-#{revision}" : "v#{version}"
+  end
+end

data/lib/mnenv/models/version.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Mnenv
+  class ArtifactVersion < Lutaml::Model::Serializable
+    attribute :version, :string
+    attribute :published_at, :date_time
+    attribute :parsed_at, :date_time
+
+    key_value do
+      map 'version', to: :version
+      map 'published_at', to: :published_at
+      map 'parsed_at', to: :parsed_at
+    end
+
+    def <=>(other) = version_parts <=> other.version_parts
+
+    def display_name = "v#{version}"
+
+    protected
+
+    def version_parts = version.split('.').map(&:to_i)
+  end
+end

data/lib/mnenv/models.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+require_relative 'models/version'
+require_relative 'models/gemfile_version'
+require_relative 'models/snap_version'
+require_relative 'models/homebrew_version'
+require_relative 'models/chocolatey_version'

data/lib/mnenv/repository.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'fileutils'
+
+module Mnenv
+  class Repository
+    attr_reader :data_dir, :versions_file_path
+
+    def initialize(data_dir: nil)
+      @data_dir = data_dir || default_data_dir
+      @versions_file_path = File.join(@data_dir, 'versions.yaml')
+      @versions_cache = {}
+      load if File.file?(versions_file_path)
+    end
+
+    def find(version_number) = @versions_cache[version_number]
+
+    def all = @versions_cache.values.sort
+
+    def latest = all.last
+
+    def count = @versions_cache.size
+
+    def exists?(version_number) = @versions_cache.key?(version_number)
+
+    def save(version)
+      @versions_cache[version.version] = version
+      persist
+    end
+
+    def save_all(versions)
+      versions.each { |v| @versions_cache[v.version] = v }
+      persist
+    end
+
+    protected
+
+    def load
+      data = YAML.load_file(versions_file_path)
+      return if data.nil? || data['versions'].nil?
+
+      data['versions'].each do |version_hash|
+        version = version_class.new(version_hash)
+        @versions_cache[version.version] = version
+      end
+    end
+
+    def persist
+      FileUtils.mkdir_p(data_dir)
+      output = {
+        'metadata' => metadata,
+        'versions' => @versions_cache.values.sort.map { |v| version_to_hash(v) }
+      }
+      File.write(versions_file_path, output.to_yaml)
+    end
+
+    def metadata
+      {
+        'generated_at' => Time.now.utc.strftime('%Y-%m-%dT%H:%M:%SZ'),
+        'source' => source_name,
+        'count' => count,
+        'latest_version' => latest&.version
+      }
+    end
+
+    def version_class = raise NotImplementedError
+
+    def source_name = raise NotImplementedError
+
+    def default_data_dir = File.join(__dir__, '..', '..', 'data', source_name.to_s)
+
+    private
+
+    def version_to_hash(version)
+      hash = {
+        'version' => version.version,
+        'published_at' => format_timestamp(version.published_at),
+        'parsed_at' => format_timestamp(version.parsed_at)
+      }
+
+      # Add subclass-specific fields
+      case version
+      when GemfileVersion
+        hash['gemfile_exists'] = version.gemfile_exists
+        hash['gemfile_path'] = version.gemfile_path
+        hash['gemfile_lock_path'] = version.gemfile_lock_path
+      when SnapVersion
+        hash['revision'] = version.revision
+        hash['arch'] = version.arch
+        hash['channel'] = version.channel
+      when HomebrewVersion
+        hash['tag_name'] = version.tag_name
+        hash['commit_sha'] = version.commit_sha
+      when ChocolateyVersion
+        hash['package_name'] = version.package_name
+        hash['is_pre_release'] = version.is_pre_release
+      end
+
+      hash
+    end
+
+    def format_timestamp(t) = t&.strftime('%Y-%m-%dT%H:%M:%SZ')
+  end
+end

data/lib/mnenv/snap/fetcher.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative '../fetcher'
+require_relative '../snap_repository'
+require_relative '../models/snap_version'
+require_relative '../logger'
+require 'uri'
+require 'json'
+require 'fileutils'
+require 'net/http'
+
+module Mnenv
+  module Snap
+    # Fetches Snap versions from Snapcraft API and merges with historical YAML data.
+    # The YAML file (data/snap/versions.yaml) is the single source of truth.
+    # Fetcher loads existing YAML, merges with API data, saves back to YAML.
+    # Snap cannot support "revamp" as it would lose historical data.
+    class Fetcher < Mnenv::Fetcher
+      SNAP_NAME = 'metanorma'
+      SNAP_ID = 'QkvhpBkFKaDwHMR2LTS3S9Bm0Ek6io11'
+      METADATA_API_URL = 'https://api.snapcraft.io/api/v1/snaps/metadata'
+
+      CHANNELS = %w[stable candidate beta edge].freeze
+      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 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')
+          )
+        end
+
+        version_map.values.sort
+      end
+
+      private
+
+      def snap_key(version)
+        "#{version.version}-#{version.revision}-#{version.arch}-#{version.channel}"
+      end
+
+      def snap_key_hash(hash)
+        "#{hash.fetch('version')}-#{hash.fetch('revision')}-#{hash.fetch('arch')}-#{hash.fetch('channel')}"
+      end
+
+      # Fetch current heads from snap_metadata API for all channel/arch combinations
+      def fetch_current_heads
+        versions = []
+
+        CHANNELS.each do |channel|
+          ARCHITECTURES.each do |arch|
+            body = {
+              snaps: [{
+                snap_id: SNAP_ID,
+                channel: channel,
+                architecture: arch
+              }],
+              fields: %w[version revision channel architecture download_url]
+            }
+
+            uri = URI(METADATA_API_URL)
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = true
+            request = Net::HTTP::Post.new(uri.path)
+            request['Content-Type'] = 'application/json'
+            request['X-Ubuntu-Series'] = '16'
+            request.body = body.to_json
+
+            response = http.request(request)
+            data = JSON.parse(response.body)
+
+            if data['_embedded'] && data['_embedded']['clickindex:package']
+              pkg = data['_embedded']['clickindex:package'][0]
+              versions << {
+                'version' => pkg['version'],
+                'revision' => pkg['revision'],
+                'arch' => arch,
+                'channel' => channel
+              }
+            end
+          rescue StandardError => e
+            Logger.warning "Failed to fetch #{channel}/#{arch}: #{e.message}"
+          end
+        end
+
+        versions
+      end
+
+      def default_repository = @default_repository ||= SnapRepository.new
+    end
+  end
+end

data/lib/mnenv/snap_repository.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative 'repository'
+require_relative 'models/snap_version'
+
+module Mnenv
+  class SnapRepository < Repository
+    def version_class = SnapVersion
+    def source_name = :snap
+
+    # Override save and save_all to use composite key for Snap
+    # Since same version can have multiple revisions/arch/channels
+    def save(version)
+      @versions_cache[snap_key(version)] = version
+      persist
+    end
+
+    def save_all(versions)
+      versions.each { |v| @versions_cache[snap_key(v)] = v }
+      persist
+    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'
+      end
+    end
+
+    # Override load to handle snap composite keys
+    def load
+      data = YAML.load_file(versions_file_path)
+      return if data.nil? || data['versions'].nil?
+
+      data['versions'].each do |version_hash|
+        version = version_class.new(version_hash)
+        @versions_cache[snap_key(version)] = version
+      end
+    end
+  end
+end

data/lib/mnenv/version.rb

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

data/lib/mnenv.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+require 'thor'
+
+require_relative 'mnenv/models'
+require_relative 'mnenv/commands'
+require_relative 'mnenv/cli'

data/mnenv.gemspec

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'lib/mnenv/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'mnenv'
+  spec.version       = Mnenv::VERSION
+  spec.authors       = ['Ribose Inc.']
+  spec.email         = ['open.source@ribose.com']
+
+  spec.summary       = 'Version discovery and management for Metanorma (mnenv)'
+  spec.description   = 'Unified interface for discovering and managing Metanorma ' \
+                       'versions from Gemfile (Docker), Snap, Homebrew, and Chocolatey sources. ' \
+                       'Provides mnenv CLI command for querying version information.'
+  spec.homepage      = 'https://github.com/metanorma/versions'
+  spec.license       = 'MIT'
+
+  spec.required_ruby_version = '>= 3.1'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  # Specify which files should be added to the gem
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:test|spec|features)/|\.(?:git|travis|circleci)|appveyor)}) ||
+        f.start_with?('.')
+    end
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = ['mnenv']
+  spec.require_paths = ['lib']
+
+  # Runtime dependencies
+  spec.add_dependency 'activesupport'
+  spec.add_dependency 'lutaml-model', '~> 0.7'
+  spec.add_dependency 'lutaml-xsd', '~> 1.0'
+  spec.add_dependency 'moxml'
+  spec.add_dependency 'nokogiri'
+  spec.add_dependency 'paint'
+  spec.add_dependency 'thor', '~> 1.0'
+end