mnenv 0.1.0 → 0.1.1

data/lib/mnenv/cli.rb

@@ -2,18 +2,49 @@
 
 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
+  # Autoload constants for lazy loading
+  autoload :VERSION, 'mnenv/version'
+  autoload :GemfileRepository, 'mnenv/gemfile_repository'
+  autoload :SnapRepository, 'mnenv/snap_repository'
+  autoload :HomebrewRepository, 'mnenv/homebrew_repository'
+  autoload :ChocolateyRepository, 'mnenv/chocolatey_repository'
+  autoload :GemfileCommand, 'mnenv/commands/gemfile_command'
+  autoload :SnapCommand, 'mnenv/commands/snap_command'
+  autoload :HomebrewCommand, 'mnenv/commands/homebrew_command'
+  autoload :ChocolateyCommand, 'mnenv/commands/chocolatey_command'
+  autoload :InstallCommand, 'mnenv/commands/install_command'
+  autoload :VersionCommand, 'mnenv/commands/version_command'
+  autoload :UninstallCommand, 'mnenv/commands/uninstall_command'
+  autoload :JsonFormatter, 'mnenv/json_formatter'
+  autoload :ShimManager, 'mnenv/shim_manager'
+  autoload :BinaryRepository, 'mnenv/binary_repository'
+
   class Cli < Thor
     package_name 'mnenv'
 
+    # Global options
+    class_option :verbose, type: :boolean, default: false, desc: 'Enable verbose output'
+    class_option :'data-dir', type: :string, desc: 'Path to data directory (default: uses ~/.mnenv/versions/data)'
+
+    # Track verbose mode and data_dir for use in other classes
+    class << self
+      def verbose?
+        @verbose ||= false
+      end
+
+      attr_accessor :data_dir
+
+      attr_writer :verbose
+    end
+
+    def initialize(*args)
+      super
+      self.class.verbose = options[:verbose]
+      self.class.data_dir = options[:'data-dir']
+    end
+
     # Platform subcommands
     desc 'gemfile SUBCOMMAND', 'Manage Ruby (Gemfile) versions'
     subcommand 'gemfile', GemfileCommand
@@ -27,12 +58,75 @@ module Mnenv
     desc 'chocolatey SUBCOMMAND', 'Manage Chocolatey versions'
     subcommand 'chocolatey', ChocolateyCommand
 
+    # Interactive installation commands
+    desc 'install [VERSION]', 'Install a Metanorma version'
+    method_option :source, type: :string, enum: %w[gemfile binary], default: 'gemfile',
+                           desc: 'Installation source (gemfile or binary)'
+    method_option :interactive, type: :boolean, aliases: '-i', default: false,
+                                desc: 'Interactive mode for version selection'
+    method_option :list, type: :boolean, aliases: '-l', default: false,
+                         desc: 'List all available Metanorma versions'
+    def install(version = nil)
+      cmd = InstallCommand.new
+      cmd.options = Thor::CoreExt::HashWithIndifferentAccess.new(options.merge(version: version))
+      cmd.install(version)
+    end
+
+    desc 'use [VERSION]', 'Set Metanorma version for current shell session'
+    method_option :source, type: :string, enum: %w[gemfile binary],
+                           desc: 'Source type (gemfile or binary)'
+    method_option :interactive, type: :boolean, aliases: '-i', default: false,
+                                desc: 'Interactive mode for version selection'
+    def use(version = nil)
+      cmd = VersionCommand.new
+      cmd.options = options
+      cmd.use(version)
+    end
+
+    desc 'global [VERSION]', 'Set default Metanorma version globally'
+    method_option :source, type: :string, enum: %w[gemfile binary],
+                           desc: 'Source type (gemfile or binary)'
+    method_option :interactive, type: :boolean, aliases: '-i', default: false,
+                                desc: 'Interactive mode for version selection'
+    def global(version = nil)
+      cmd = VersionCommand.new
+      cmd.options = options
+      cmd.global(version)
+    end
+
+    desc 'local [VERSION]', 'Set Metanorma version for current directory'
+    method_option :source, type: :string, enum: %w[gemfile binary],
+                           desc: 'Source type (gemfile or binary)'
+    method_option :interactive, type: :boolean, aliases: '-i', default: false,
+                                desc: 'Interactive mode for version selection'
+    def local(version = nil)
+      cmd = VersionCommand.new
+      cmd.options = options
+      cmd.local(version)
+    end
+
+    desc 'versions', 'List all installed Metanorma versions'
+    def versions
+      cmd = VersionCommand.new
+      cmd.versions
+    end
+
+    desc 'uninstall VERSION', 'Uninstall a Metanorma version'
+    method_option :force, type: :boolean, aliases: '-f', default: false,
+                          desc: 'Force uninstallation without confirmation'
+    def uninstall(version)
+      cmd = UninstallCommand.new
+      cmd.options = options
+      cmd.uninstall(version)
+    end
+
     # General commands
     PLATFORM_REPOSITORIES = {
       'gemfile' => GemfileRepository,
       'snap' => SnapRepository,
       'homebrew' => HomebrewRepository,
-      'chocolatey' => ChocolateyRepository
+      'chocolatey' => ChocolateyRepository,
+      'binary' => BinaryRepository
     }.freeze
 
     desc 'info PLATFORM VERSION', 'Get details for a specific version'
@@ -54,8 +148,6 @@ module Mnenv
 
       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)
@@ -66,6 +158,7 @@ module Mnenv
         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
@@ -120,5 +213,12 @@ module Mnenv
     def version
       puts "mnenv #{Mnenv::VERSION}"
     end
+
+    desc 'update', 'Update version data from metanorma/versions repository'
+    def update
+      puts 'Updating version data...'
+      Repository.update_versions
+      puts 'Version data updated successfully.'
+    end
   end
 end

data/lib/mnenv/commands/available_command.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative '../version'
+require_relative '../binary_repository'
+
+module Mnenv
+  class AvailableCommand < Thor
+    namespace :available
+
+    class_option :source, type: :string, enum: %w[gemfile binary all], default: 'all',
+                          desc: 'Source type to show (gemfile, binary, or all)'
+    class_option :format, type: :string, aliases: '-f', default: 'text',
+                          desc: 'Output format (text or json)'
+
+    desc 'gemfile', 'List available Metanorma versions from RubyGems (gemfile method)'
+    method_option :format, type: :string, aliases: '-f', default: 'text'
+    def gemfile
+      repo = GemfileRepository.new
+      versions = repo.all.sort.reverse
+
+      show_available_versions('gemfile', versions)
+    end
+
+    desc 'binary', 'List available Metanorma versions from GitHub releases (binary method)'
+    method_option :format, type: :string, aliases: '-f', default: 'text'
+    def binary
+      repo = BinaryRepository.new
+      versions = repo.all
+
+      show_available_versions('binary', versions)
+    end
+
+    desc 'all', 'List all available Metanorma versions from all sources'
+    method_option :format, type: :string, aliases: '-f', default: 'text'
+    def all
+      case options[:format]
+      when 'json'
+        output = {}
+        output['gemfile'] = format_versions_json(GemfileRepository.new.all.sort.reverse)
+        output['binary'] = format_versions_json(BinaryRepository.new.all)
+        puts JSON.pretty_generate(output)
+      else
+        puts "\n=== Gemfile (RubyGems) ==="
+        gemfile
+
+        puts "\n=== Binary (packed-mn releases) ==="
+        binary
+      end
+    end
+
+    default_task :all
+
+    private
+
+    def show_available_versions(source, versions)
+      current_version, current_source = resolve_current
+
+      case options[:format]
+      when 'json'
+        output = {
+          'source' => source,
+          'versions' => format_versions_json(versions)
+        }
+        puts JSON.pretty_generate(output)
+      else
+        puts "Available Metanorma versions (source: #{source}):"
+
+        versions.each do |v|
+          # Check if installed
+          version_dir = File.expand_path("~/.mnenv/versions/#{v.version}")
+          installed = Dir.exist?(version_dir)
+
+          # Check installed source
+          installed_source = if installed
+                               source_file = File.join(version_dir, 'source')
+                               File.exist?(source_file) ? File.read(source_file).strip : 'unknown'
+                             end
+
+          # Check if currently active
+          is_current = installed && v.version == current_version && installed_source == current_source
+
+          # Build status indicator
+          status_parts = []
+          status_parts << 'current' if is_current
+          status_parts << 'installed' if installed && !is_current
+          status = status_parts.empty? ? '' : " [#{status_parts.join(', ')}]"
+
+          # Show installed source if different
+          source_info = if installed && installed_source && installed_source != source
+                          " (as #{installed_source})"
+                        elsif installed && installed_source == source
+                          ''
+                        end
+
+          # Version display with padding
+          version_display = v.display_name
+          marker = is_current ? '*' : ' '
+          padding = ' ' * (15 - version_display.length - status.length)
+
+          puts "  #{marker} #{version_display}#{padding}#{status}#{source_info}"
+        end
+      end
+    end
+
+    def format_versions_json(versions)
+      versions.map do |v|
+        version_dir = File.expand_path("~/.mnenv/versions/#{v.version}")
+        installed = Dir.exist?(version_dir)
+        installed_source = if installed
+                             source_file = File.join(version_dir, 'source')
+                             File.exist?(source_file) ? File.read(source_file).strip : nil
+                           end
+
+        {
+          'version' => v.version,
+          'display_name' => v.display_name,
+          'published_at' => v.published_at&.iso8601,
+          'installed' => installed,
+          'installed_source' => installed_source
+        }
+      end
+    end
+
+    def resolve_current
+      # Get current version
+      version = ENV['METANORMA_VERSION']
+      unless version
+        # Check .metanorma-version file
+        dir = Dir.pwd
+        while dir && dir != '/'
+          if File.exist?(File.join(dir, '.metanorma-version'))
+            version = File.read(File.join(dir, '.metanorma-version')).strip
+            break
+          end
+          dir = File.dirname(dir)
+        end
+
+        # Check global version
+        version ||= begin
+          global_version_file = File.expand_path('~/.mnenv/version')
+          File.read(global_version_file).strip if File.exist?(global_version_file)
+        end
+      end
+
+      # Get current source
+      source = ENV['METANORMA_SOURCE']
+      unless source
+        # Check .metanorma-source file
+        dir = Dir.pwd
+        while dir && dir != '/'
+          if File.exist?(File.join(dir, '.metanorma-source'))
+            source = File.read(File.join(dir, '.metanorma-source')).strip
+            break
+          end
+          dir = File.dirname(dir)
+        end
+
+        # Check global source
+        source ||= begin
+          global_source_file = File.expand_path('~/.mnenv/source')
+          File.read(global_source_file).strip if File.exist?(global_source_file)
+        end
+      end
+
+      [version, source]
+    end
+  end
+end

data/lib/mnenv/commands/chocolatey_command.rb

@@ -4,12 +4,14 @@ require 'thor'
 require 'json'
 
 module Mnenv
+  autoload :ChocolateyRepository, 'mnenv/chocolatey_repository'
+  autoload :JsonFormatter, 'mnenv/json_formatter'
+  autoload :Chocolatey, 'mnenv/chocolatey'
+
   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
 
@@ -25,7 +27,6 @@ module Mnenv
 
     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
@@ -41,7 +42,6 @@ module Mnenv
 
     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"
@@ -49,7 +49,6 @@ module Mnenv
 
     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 }

data/lib/mnenv/commands/gemfile_command.rb

@@ -4,12 +4,14 @@ require 'thor'
 require 'json'
 
 module Mnenv
+  autoload :GemfileRepository, 'mnenv/gemfile_repository'
+  autoload :JsonFormatter, 'mnenv/json_formatter'
+  autoload :Gemfile, 'mnenv/gemfile'
+
   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
 
@@ -25,21 +27,18 @@ module Mnenv
 
     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

data/lib/mnenv/commands/homebrew_command.rb

@@ -4,12 +4,14 @@ require 'thor'
 require 'json'
 
 module Mnenv
+  autoload :HomebrewRepository, 'mnenv/homebrew_repository'
+  autoload :JsonFormatter, 'mnenv/json_formatter'
+  autoload :Homebrew, 'mnenv/homebrew'
+
   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
 
@@ -25,7 +27,6 @@ module Mnenv
 
     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
@@ -41,7 +42,6 @@ module Mnenv
 
     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"
@@ -49,7 +49,6 @@ module Mnenv
 
     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 }

data/lib/mnenv/commands/install_command.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require 'tty/prompt'
+require_relative '../installer'
+require_relative '../binary_repository'
+
+module Mnenv
+  class InstallCommand < Thor
+    namespace :install
+
+    class_option :source, type: :string, enum: %w[gemfile binary], default: 'gemfile',
+                          desc: 'Installation source (gemfile or binary)'
+    class_option :interactive, type: :boolean, aliases: '-i', default: false,
+                               desc: 'Interactive mode for version selection'
+
+    desc 'VERSION', 'Install a specific Metanorma version'
+    method_option :source, type: :string, enum: %w[gemfile binary], default: 'gemfile',
+                           desc: 'Installation source (gemfile or binary)'
+    method_option :interactive, type: :boolean, aliases: '-i', default: false,
+                                desc: 'Interactive mode for version selection'
+    method_option :list, type: :boolean, aliases: '-l', default: false,
+                         desc: 'List all available Metanorma versions'
+    def install(version = nil)
+      # If --list flag is provided, show available versions and exit
+      return list_available_versions if options[:list]
+
+      # If no version provided or interactive mode, prompt for selection
+      if options[:interactive] || version.nil?
+        version, source = select_installation_interactive
+      else
+        source = options[:source]
+      end
+
+      installer = InstallerFactory.create(version, source: source)
+
+      if installer.installed?
+        prompt = TTY::Prompt.new
+        unless prompt.yes?("Version #{version} (source: #{source}) is already installed. Reinstall?")
+          puts 'Installation cancelled.'
+          return
+        end
+      end
+
+      puts "Installing Metanorma #{version} (source: #{source})..."
+      installer.install
+      puts "Successfully installed Metanorma #{version} (source: #{source})!"
+    rescue Installer::InstallationError => e
+      warn "Error: #{e.message}"
+      exit 1
+    end
+
+    default_task :install
+
+    private
+
+    def list_available_versions
+      current_version, current_source = resolve_current
+      current_platform = detect_platform
+
+      puts "\nAvailable Metanorma versions:"
+      puts "(gemfile = source build, binary = prebuilt for specific platforms)\n"
+
+      # Get all unique versions from both sources
+      gemfile_repo = GemfileRepository.new
+      binary_repo = BinaryRepository.new
+
+      gemfile_versions = gemfile_repo.all.sort.reverse
+      binary_versions = binary_repo.all
+
+      # Combine all versions
+      all_versions = Hash.new { |h, k| h[k] = { gemfile: false, binary: false } }
+
+      gemfile_versions.each do |v|
+        all_versions[v.version][:gemfile] = true
+        all_versions[v.version][:gemfile_obj] = v
+      end
+
+      binary_versions.each do |v|
+        all_versions[v.version][:binary] = true
+        all_versions[v.version][:binary_obj] = v
+        all_versions[v.version][:binary_platforms] = extract_platforms(v.assets)
+      end
+
+      # Check what's installed (from installed directory, not versions data)
+      if Dir.exist?(Paths::INSTALLED_DIR)
+        Dir.glob("#{Paths::INSTALLED_DIR}/*/").each do |dir|
+          version = File.basename(dir)
+          source_file = File.join(dir, 'source')
+          source = File.exist?(source_file) ? File.read(source_file).strip : nil
+          all_versions[version][:"installed_#{source}"] = true if source && all_versions[version]
+        end
+      end
+
+      # Display sorted versions (newest first)
+      all_versions.sort.reverse.each do |version, info|
+        # Build sources string with platform info for binary
+        sources = []
+        sources << 'gemfile' if info[:gemfile]
+        if info[:binary]
+          platforms = info[:binary_platforms] || []
+          if platforms.any?
+            # Highlight current platform
+            platform_display = platforms.map do |p|
+              p == current_platform ? "#{p}*" : p
+            end.join(', ')
+            sources << "binary [#{platform_display}]"
+          else
+            sources << 'binary'
+          end
+        end
+
+        # Check if current
+        is_current = version == current_version && sources.any? { |s| s.include?(current_source.to_s) }
+        marker = is_current ? '* ' : '  '
+
+        # Version display
+        version_display = version.ljust(15)
+
+        # Sources display
+        sources_display = sources.join(', ')
+
+        # Installed status
+        installed = []
+        installed << 'gemfile' if info[:installed_gemfile]
+        installed << 'binary' if info[:installed_binary]
+        installed_display = installed.empty? ? '' : " [installed: #{installed.join(', ')}]"
+
+        puts "  #{marker}#{version_display}(#{sources_display})#{installed_display}"
+      end
+
+      # Legend
+      puts "\nLegend:"
+      puts '  * Current version / platform'
+      puts '  [installed: ...] = Already installed locally'
+      puts "  Detected platform: #{current_platform}"
+      puts "\nInstall with: mnenv install VERSION --source SOURCE"
+      puts 'Examples:'
+      puts '  mnenv install 1.14.4 --source gemfile'
+      puts '  mnenv install 1.14.4 --source binary'
+    end
+
+    def extract_platforms(assets)
+      return [] unless assets
+
+      assets.filter_map do |asset|
+        # Match patterns like metanorma-darwin-arm64.tgz or metanorma-linux-x86_64.tgz
+        case asset
+        when /darwin/ then 'macos'
+        when /linux/ then 'linux'
+        when /windows/ then 'windows'
+        end
+      end.uniq.sort
+    end
+
+    def detect_platform
+      case RbConfig::CONFIG['host_os']
+      when /linux/ then 'linux'
+      when /darwin/ then 'macos'
+      when /mswin|mingw|cygwin/ then 'windows'
+      else 'unknown'
+      end
+    end
+
+    def resolve_current
+      # Get current version
+      version = ENV['METANORMA_VERSION']
+      unless version
+        # Check .metanorma-version file
+        dir = Dir.pwd
+        while dir && dir != '/'
+          if File.exist?(File.join(dir, '.metanorma-version'))
+            version = File.read(File.join(dir, '.metanorma-version')).strip
+            break
+          end
+          dir = File.dirname(dir)
+        end
+
+        # Check global version
+        version ||= (File.read(Paths::VERSION_FILE).strip if File.exist?(Paths::VERSION_FILE))
+
+      end
+
+      # Get current source
+      source = ENV['METANORMA_SOURCE']
+      unless source
+        # Check .metanorma-source file
+        dir = Dir.pwd
+        while dir && dir != '/'
+          if File.exist?(File.join(dir, '.metanorma-source'))
+            source = File.read(File.join(dir, '.metanorma-source')).strip
+            break
+          end
+          dir = File.dirname(dir)
+        end
+
+        # Check global source
+        source ||= (File.read(Paths::SOURCE_FILE).strip if File.exist?(Paths::SOURCE_FILE))
+
+      end
+
+      [version, source]
+    end
+
+    def select_installation_interactive
+      repo = GemfileRepository.new
+      prompt = TTY::Prompt.new
+
+      # First, select source
+      source = prompt.select('Select installation source:', [
+                               { name: 'Gemfile (faster, on-demand loading, requires dev tools, upgradable)',
+                                 value: 'gemfile' },
+                               { name: 'Binary (slower, full-stack memory load, no dev tools, fixed)',
+                                 value: 'binary' }
+                             ])
+
+      # Then, select version
+      choices = repo.all.sort.map do |v|
+        version_dir = Paths.version_install_dir(v.version)
+        installed = Dir.exist?(version_dir) && File.exist?(File.join(version_dir, 'source'))
+        installed_source = if installed
+                             src = File.read(File.join(version_dir, 'source')).strip
+                             src.empty? ? '' : "(#{src})"
+                           else
+                             ''
+                           end
+        { name: "#{v.display_name} #{installed ? "[installed: #{installed_source}]" : ''}", value: v.version }
+      end
+
+      version = prompt.select('Select a version to install:', choices)
+
+      [version, source]
+    end
+  end
+end