mnenv 0.1.0

data/lib/mnenv/cli.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'json'
+require_relative 'models'
+require_relative 'commands'
+require_relative 'json_formatter'
+require_relative 'gemfile_repository'
+require_relative 'snap_repository'
+require_relative 'homebrew_repository'
+require_relative 'chocolatey_repository'
+
+module Mnenv
+  class Cli < Thor
+    package_name 'mnenv'
+
+    # Platform subcommands
+    desc 'gemfile SUBCOMMAND', 'Manage Ruby (Gemfile) versions'
+    subcommand 'gemfile', GemfileCommand
+
+    desc 'snap SUBCOMMAND', 'Manage Snap versions'
+    subcommand 'snap', SnapCommand
+
+    desc 'homebrew SUBCOMMAND', 'Manage Homebrew versions'
+    subcommand 'homebrew', HomebrewCommand
+
+    desc 'chocolatey SUBCOMMAND', 'Manage Chocolatey versions'
+    subcommand 'chocolatey', ChocolateyCommand
+
+    # General commands
+    PLATFORM_REPOSITORIES = {
+      'gemfile' => GemfileRepository,
+      'snap' => SnapRepository,
+      'homebrew' => HomebrewRepository,
+      'chocolatey' => ChocolateyRepository
+    }.freeze
+
+    desc 'info PLATFORM VERSION', 'Get details for a specific version'
+    method_option :format, type: :string, aliases: '-f', default: 'json'
+    def info(platform, version_number)
+      repo_class = PLATFORM_REPOSITORIES[platform]
+      unless repo_class
+        puts "Error: Unknown platform '#{platform}'. Available: #{PLATFORM_REPOSITORIES.keys.join(', ')}"
+        exit 1
+      end
+
+      repo = repo_class.new
+      version_obj = repo.find(version_number)
+
+      unless version_obj
+        puts "Error: Version '#{version_number}' not found for platform '#{platform}'"
+        exit 1
+      end
+
+      case options[:format]
+      when 'json'
+        require_relative 'json_formatter'
+        require 'json'
+        output = JsonFormatter.format_version(version_obj)
+        output['platform'] = platform
+        puts JSON.pretty_generate(output)
+      else
+        puts "#{platform.capitalize} version #{version_obj.display_name}:"
+        puts "  Version: #{version_obj.version}"
+        puts "  Published: #{version_obj.published_at || 'N/A'}"
+        puts "  Parsed: #{version_obj.parsed_at || 'N/A'}"
+        version_obj.to_h.each do |k, v|
+          next if %w[version published_at parsed_at].include?(k)
+          puts "  #{k}: #{v}"
+        end
+      end
+    end
+
+    desc 'list PLATFORM', 'List versions for a platform'
+    method_option :format, type: :string, aliases: '-f', default: 'json'
+    def list(platform)
+      repo_class = PLATFORM_REPOSITORIES[platform]
+      unless repo_class
+        puts "Error: Unknown platform '#{platform}'. Available: #{PLATFORM_REPOSITORIES.keys.join(', ')}"
+        exit 1
+      end
+
+      repo = repo_class.new
+      versions = repo.all
+
+      case options[:format]
+      when 'json'
+        output = JsonFormatter.format_versions(versions)
+        output['platform'] = platform
+        puts JSON.pretty_generate(output)
+      else
+        puts "#{platform.capitalize} versions (#{versions.size}):"
+        versions.each do |v|
+          published = v.published_at ? " (#{v.published_at.strftime('%Y-%m-%d')})" : ''
+          puts "  #{v.display_name}#{published}"
+        end
+      end
+    end
+
+    desc 'list-all', 'List all versions from all platforms'
+    method_option :format, type: :string, aliases: '-f', default: 'json'
+    def list_all
+      case options[:format]
+      when 'json'
+        output = {}
+        PLATFORM_REPOSITORIES.each do |name, repo_class|
+          repo = repo_class.new
+          output[name] = JsonFormatter.format_versions(repo.all)
+        end
+
+        puts JSON.pretty_generate(output)
+      else
+        PLATFORM_REPOSITORIES.each_key do |platform|
+          list(platform)
+        end
+      end
+    end
+
+    desc 'version', 'Show mnenv version'
+    def version
+      puts "mnenv #{Mnenv::VERSION}"
+    end
+  end
+end

data/lib/mnenv/commands/chocolatey_command.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'json'
+
+module Mnenv
+  class ChocolateyCommand < Thor
+    desc 'list', 'List all Chocolatey versions'
+    method_option :format, type: :string, aliases: '-f', default: 'text'
+    def list
+      require_relative '../chocolatey_repository'
+      require_relative '../json_formatter'
+      repo = ChocolateyRepository.new
+      versions = repo.all
+
+      case options[:format]
+      when 'json'
+        output = JsonFormatter.format_versions(versions)
+        output['platform'] = 'chocolatey'
+        puts JSON.pretty_generate(output)
+      else
+        list_versions_text(versions, 'Chocolatey')
+      end
+    end
+
+    desc 'refresh', 'Fetch and add new Chocolatey versions'
+    def refresh
+      require_relative '../chocolatey/fetcher'
+      fetcher = Chocolatey::Fetcher.new
+      existing = fetcher.repository.all.map(&:version)
+      remote_versions = fetcher.fetch_all
+      new_versions = remote_versions.reject { |v| existing.include?(v.version) }
+
+      if new_versions.empty?
+        puts 'No new Chocolatey versions found'
+      else
+        fetcher.repository.save_all(new_versions)
+        puts "Added #{new_versions.size} new Chocolatey versions"
+      end
+    end
+
+    desc 'revamp', 'Re-fetch all Chocolatey versions'
+    def revamp
+      require_relative '../chocolatey/fetcher'
+      fetcher = Chocolatey::Fetcher.new
+      versions = fetcher.fetch_and_save
+      puts "Revamped #{versions.size} Chocolatey versions"
+    end
+
+    desc 'update VERSION', 'Update a specific Chocolatey version'
+    def update(version)
+      require_relative '../chocolatey/fetcher'
+      fetcher = Chocolatey::Fetcher.new
+      versions = fetcher.fetch_all
+      target = versions.find { |v| v.version == version }
+
+      if target
+        fetcher.repository.save(target)
+        puts "Updated Chocolatey version #{version}"
+      else
+        puts "Chocolatey version #{version} not found"
+        exit 1
+      end
+    end
+
+    private
+
+    def list_versions_text(versions, name)
+      puts "#{name} versions (#{versions.size}):"
+      versions.each do |v|
+        published = v.published_at ? " (#{v.published_at.strftime('%Y-%m-%d')})" : ''
+        puts "  #{v.display_name}#{published}"
+      end
+    end
+  end
+end

data/lib/mnenv/commands/gemfile_command.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'json'
+
+module Mnenv
+  class GemfileCommand < Thor
+    desc 'list', 'List all Gemfile (Ruby) versions'
+    method_option :format, type: :string, aliases: '-f', default: 'text'
+    def list
+      require_relative '../gemfile_repository'
+      require_relative '../json_formatter'
+      repo = GemfileRepository.new
+      versions = repo.all
+
+      case options[:format]
+      when 'json'
+        output = JsonFormatter.format_versions(versions)
+        output['platform'] = 'ruby'
+        puts JSON.pretty_generate(output)
+      else
+        list_versions_text(versions, 'Ruby (Gemfile)')
+      end
+    end
+
+    desc 'refresh', 'Extract new Gemfiles (incremental mode)'
+    def refresh
+      require_relative '../gemfile/extractor'
+      extractor = Gemfile::Extractor.new(mode: :incremental)
+      extractor.run
+    end
+
+    desc 'revamp', 'Re-extract all Gemfiles'
+    def revamp
+      require_relative '../gemfile/extractor'
+      extractor = Gemfile::Extractor.new(mode: :revamp)
+      extractor.run
+    end
+
+    desc 'update VERSION', 'Re-extract specific version'
+    def update(version)
+      require_relative '../gemfile/extractor'
+      extractor = Gemfile::Extractor.new(mode: :replace, target_version: version)
+      extractor.run
+    end
+
+    private
+
+    def list_versions_text(versions, name)
+      puts "#{name} versions (#{versions.size}):"
+      versions.each do |v|
+        published = v.published_at ? " (#{v.published_at.strftime('%Y-%m-%d')})" : ''
+        puts "  #{v.display_name}#{published}"
+      end
+    end
+  end
+end

data/lib/mnenv/commands/homebrew_command.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'json'
+
+module Mnenv
+  class HomebrewCommand < Thor
+    desc 'list', 'List all Homebrew versions'
+    method_option :format, type: :string, aliases: '-f', default: 'text'
+    def list
+      require_relative '../homebrew_repository'
+      require_relative '../json_formatter'
+      repo = HomebrewRepository.new
+      versions = repo.all
+
+      case options[:format]
+      when 'json'
+        output = JsonFormatter.format_versions(versions)
+        output['platform'] = 'homebrew'
+        puts JSON.pretty_generate(output)
+      else
+        list_versions_text(versions, 'Homebrew')
+      end
+    end
+
+    desc 'refresh', 'Fetch and add new Homebrew versions'
+    def refresh
+      require_relative '../homebrew/fetcher'
+      fetcher = Homebrew::Fetcher.new
+      existing = fetcher.repository.all.map(&:version)
+      remote_versions = fetcher.fetch_all
+      new_versions = remote_versions.reject { |v| existing.include?(v.version) }
+
+      if new_versions.empty?
+        puts 'No new Homebrew versions found'
+      else
+        fetcher.repository.save_all(new_versions)
+        puts "Added #{new_versions.size} new Homebrew versions"
+      end
+    end
+
+    desc 'revamp', 'Re-fetch all Homebrew versions'
+    def revamp
+      require_relative '../homebrew/fetcher'
+      fetcher = Homebrew::Fetcher.new
+      versions = fetcher.fetch_and_save
+      puts "Revamped #{versions.size} Homebrew versions"
+    end
+
+    desc 'update VERSION', 'Update a specific Homebrew version'
+    def update(version)
+      require_relative '../homebrew/fetcher'
+      fetcher = Homebrew::Fetcher.new
+      versions = fetcher.fetch_all
+      target = versions.find { |v| v.version == version }
+
+      if target
+        fetcher.repository.save(target)
+        puts "Updated Homebrew version #{version}"
+      else
+        puts "Homebrew version #{version} not found"
+        exit 1
+      end
+    end
+
+    private
+
+    def list_versions_text(versions, name)
+      puts "#{name} versions (#{versions.size}):"
+      versions.each do |v|
+        published = v.published_at ? " (#{v.published_at.strftime('%Y-%m-%d')})" : ''
+        puts "  #{v.display_name}#{published}"
+      end
+    end
+  end
+end

data/lib/mnenv/commands/snap_command.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'json'
+
+module Mnenv
+  class SnapCommand < Thor
+    desc 'list', 'List all Snap versions'
+    method_option :format, type: :string, aliases: '-f', default: 'text'
+    def list
+      require_relative '../snap_repository'
+      require_relative '../json_formatter'
+      repo = SnapRepository.new
+      versions = repo.all
+
+      case options[:format]
+      when 'json'
+        output = JsonFormatter.format_versions(versions)
+        output['platform'] = 'snap'
+        puts JSON.pretty_generate(output)
+      else
+        list_versions_text(versions, 'Snap')
+      end
+    end
+
+    desc 'refresh', 'Fetch and add new Snap versions (incremental)'
+    def refresh
+      require_relative '../snap/fetcher'
+      require_relative '../snap_repository'
+      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}" }
+      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
+
+      if new_versions.empty?
+        puts 'No new Snap versions found'
+      else
+        repo.save_all(new_versions)
+        puts "Added #{new_versions.size} new Snap versions"
+      end
+    end
+
+    desc 'revamp', 'Re-fetch all Snap versions'
+    def revamp
+      require_relative '../snap/fetcher'
+      fetcher = Snap::Fetcher.new
+      versions = fetcher.fetch_and_save
+      puts "Revamped #{versions.size} Snap versions"
+    end
+
+    desc 'update VERSION', 'Update a specific Snap version (all arch/channel combinations)'
+    def update(version)
+      require_relative '../snap/fetcher'
+      fetcher = Snap::Fetcher.new
+      versions = fetcher.fetch_all
+      targets = versions.select { |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"
+        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}"
+      end
+    end
+
+    private
+
+    def list_versions_text(versions, name)
+      puts "#{name} versions (#{versions.size}):"
+      versions.each do |v|
+        published = v.published_at ? " (#{v.published_at.strftime('%Y-%m-%d')})" : ''
+        puts "  #{v.display_name}#{published}"
+      end
+    end
+  end
+end

data/lib/mnenv/commands.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative 'commands/gemfile_command'
+require_relative 'commands/snap_command'
+require_relative 'commands/homebrew_command'
+require_relative 'commands/chocolatey_command'

data/lib/mnenv/fetcher.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'open-uri'
+
+module Mnenv
+  class Fetcher
+    attr_reader :repository
+
+    def initialize(repository: nil)
+      @repository = repository || default_repository
+    end
+
+    def fetch_all
+      raise NotImplementedError
+    end
+
+    def fetch_and_save
+      versions = fetch_all
+      repository.save_all(versions)
+      versions
+    end
+
+    protected
+
+    def fetch_json(uri) = JSON.parse(URI(uri).open.read)
+
+    def default_repository = raise NotImplementedError
+  end
+end

data/lib/mnenv/gemfile/extractor.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require_relative '../logger'
+require_relative '../gemfile_repository'
+require_relative './fetcher'
+require_relative '../models/gemfile_version'
+require 'fileutils'
+
+module Mnenv
+  module Gemfile
+    class Extractor
+      ExtractionMode = %i[incremental replace revamp].freeze
+
+      attr_reader :mode, :repository, :fetcher, :target_version
+
+      def initialize(mode: :incremental, repository: nil, fetcher: nil, target_version: nil)
+        @mode = mode || :incremental
+        @repository = repository || GemfileRepository.new
+        @fetcher = fetcher || Fetcher.new(repository: @repository)
+        @target_version = target_version
+      end
+
+      def run
+        Logger.header "Starting Gemfile extraction (mode: #{mode})"
+
+        case mode
+        when :incremental then extract_incremental
+        when :replace then extract_replace
+        when :revamp then extract_revamp
+        end
+
+        Logger.success 'Extraction complete'
+      end
+
+      private
+
+      def extract_incremental
+        remote_versions = fetcher.fetch_all
+        existing_versions = repository.all.select { |v| v.exists_locally? }.map(&:version)
+
+        missing = remote_versions.reject { |v| existing_versions.include?(v.version) }
+
+        Logger.info "Found #{missing.size} new versions"
+
+        missing.each { |v| extract_version(v) }
+      end
+
+      def extract_replace
+        raise 'target_version required for replace mode' unless target_version
+
+        remote_version = fetcher.fetch_all.find { |v| v.version == target_version }
+        raise "Version #{target_version} not found remotely" unless remote_version
+
+        local_version = repository.find(target_version)
+        remove_gemfiles(local_version) if local_version
+
+        extract_version(remote_version)
+      end
+
+      def extract_revamp
+        remote_versions = fetcher.fetch_all
+
+        Logger.info "Re-extracting #{remote_versions.size} versions"
+
+        remote_versions.each { |v| extract_version(v) }
+      end
+
+      def extract_version(version)
+        Logger.pulling version.version
+        pull_docker_image(version.version)
+
+        Logger.section "Extracting Gemfiles from #{version.version}"
+        extract_gemfiles(version)
+
+        cleanup_docker_image(version.version)
+
+        repository.save(version)
+      end
+
+      def pull_docker_image(version_number)
+        system('docker', 'pull', "#{Fetcher::DOCKER_IMAGE}:#{version_number}", out: File::NULL)
+        raise 'Failed to pull Docker image' unless $?.success?
+      end
+
+      def extract_gemfiles(version)
+        FileUtils.mkdir_p(version.directory_path)
+
+        script = gemfile_extraction_script
+        cmd = "docker run --rm --entrypoint sh #{Fetcher::DOCKER_IMAGE}:#{version.version} -c '#{script}'"
+        output = `#{cmd}`
+
+        raise "Extraction failed for #{version.version}" unless $?.success?
+
+        gemfile, gemfile_lock = parse_gemfile_output(output)
+
+        File.write(version.gemfile_path_calc, gemfile)
+        File.write(version.gemfile_lock_path_calc, gemfile_lock)
+
+        Logger.extracted version.version
+      end
+
+      def gemfile_extraction_script
+        <<~SCRIPT
+          for path in /metanorma/Gemfile /setup/Gemfile /Gemfile /root/Gemfile; do
+            if [ -f "$path" ]; then
+              gemfile_dir=$(dirname "$path")
+              echo "GEMFILE_DIR=$gemfile_dir"
+              cat "$path"
+              echo "===GEMFILE.EOF==="
+              cat "$gemfile_dir/Gemfile.lock"
+              exit 0
+            fi
+          done
+          echo "ERROR: No Gemfile found"
+          exit 1
+        SCRIPT
+      end
+
+      def parse_gemfile_output(output)
+        parts = output.split('===GEMFILE.EOF===')
+        raise 'Failed to parse output' if parts.size < 2
+
+        gemfile = parts[0].sub(/GEMFILE_DIR=.+\n/, '')
+        gemfile_lock = parts[1]
+
+        [gemfile.strip, gemfile_lock.strip]
+      end
+
+      def remove_gemfiles(version)
+        FileUtils.rm_f([version.gemfile_path_calc, version.gemfile_lock_path_calc])
+        Logger.info "Removed existing Gemfiles for #{version.version}"
+      end
+
+      def cleanup_docker_image(version_number)
+        system('docker', 'rmi', '-f', "#{Fetcher::DOCKER_IMAGE}:#{version_number}",
+               out: File::NULL, err: File::NULL)
+      end
+    end
+  end
+end

data/lib/mnenv/gemfile/fetcher.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../fetcher'
+require_relative '../gemfile_repository'
+require_relative '../models/gemfile_version'
+
+module Mnenv
+  module Gemfile
+    class Fetcher < Mnenv::Fetcher
+      DOCKER_IMAGE = 'metanorma/metanorma'
+      API_BASE = "https://registry.hub.docker.com/v2/repositories/#{DOCKER_IMAGE}/tags".freeze
+
+      def fetch_all
+        uri = URI("#{API_BASE}?page_size=100")
+        versions = []
+
+        loop do
+          data = fetch_json(uri)
+          data['results'].each do |result|
+            name = result['name']
+            next unless name.match?(/^\d+\.\d+\.\d+$/)
+
+            versions << GemfileVersion.new(
+              version: name,
+              published_at: parse_timestamp(result['tag_last_pushed'])
+            )
+          end
+          break unless data['next']
+
+          uri = URI(data['next'])
+        end
+
+        versions.sort
+      end
+
+      private
+
+      def parse_timestamp(value) = value&.then { |v| Time.parse(v) }
+
+      def default_repository = @default_repository ||= GemfileRepository.new
+    end
+  end
+end

data/lib/mnenv/gemfile_repository.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'repository'
+require_relative 'models/gemfile_version'
+
+module Mnenv
+  class GemfileRepository < Repository
+    def version_class = GemfileVersion
+    def source_name = :gemfile
+
+    def default_data_dir = File.join(__dir__, '..', '..', 'data', 'gemfile')
+  end
+end