mnenv 0.1.0 → 0.1.2

data/lib/mnenv/shells/power_shell.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Mnenv
+  module Shells
+    # PowerShell shell implementation (Windows)
+    class PowerShellShell < BaseShell
+      def name
+        'powershell'
+      end
+
+      def shim_extension
+        '.ps1'
+      end
+
+      def shim_content(executable_name)
+        <<~SHIM
+          # mnenv shim for PowerShell
+          $ErrorActionPreference = "Stop"
+
+          $MNENV_ROOT = if ($env:MNENV_ROOT) { $env:MNENV_ROOT } else { "$env:USERPROFILE\\.mnenv" }
+
+          # Resolve version and source using mnenv resolver
+          $versionFile = "$MNENV_ROOT\\version"
+          $sourceFile = "$MNENV_ROOT\\source"
+
+          # Check environment variables first
+          $VERSION = $env:METANORMA_VERSION
+          $SOURCE = $env:METANORMA_SOURCE
+
+          # Check local .metanorma-version file
+          if (-not $VERSION) {
+            $dir = (Get-Location).Path
+            $root = [System.IO.Path]::GetPathRoot($dir)
+            while ($dir -and $dir -ne $root) {
+              $localVersionFile = Join-Path $dir ".metanorma-version"
+              if (Test-Path $localVersionFile) {
+                $VERSION = Get-Content $localVersionFile -Raw
+                $VERSION = $VERSION.Trim()
+                break
+              }
+              $localSourceFile = Join-Path $dir ".metanorma-source"
+              if (-not $SOURCE -and (Test-Path $localSourceFile)) {
+                $SOURCE = Get-Content $localSourceFile -Raw
+                $SOURCE = $SOURCE.Trim()
+              }
+              $dir = Split-Path $dir -Parent
+            }
+          }
+
+          # Check global version file
+          if (-not $VERSION -and (Test-Path $versionFile)) {
+            $VERSION = Get-Content $versionFile -Raw
+            $VERSION = $VERSION.Trim()
+          }
+
+          if (-not $SOURCE -and (Test-Path $sourceFile)) {
+            $SOURCE = Get-Content $sourceFile -Raw
+            $SOURCE = $SOURCE.Trim()
+          }
+
+          # Default source
+          if (-not $SOURCE) {
+            $SOURCE = "gemfile"
+          }
+
+          if (-not $VERSION) {
+            Write-Error "mnenv: version not set or invalid"
+            Write-Error "Set a version with: mnenv global <version> or mnenv local <version>"
+            exit 1
+          }
+
+          # Determine executable path based on source
+          # Installed versions are in $MNENV_ROOT\\installed\\<version>-<source>\\
+          if ($SOURCE -eq "binary") {
+            $EXECUTABLE = "$MNENV_ROOT\\installed\\$VERSION-$SOURCE\\metanorma.exe"
+          } else {
+            # Bundler creates .cmd files on Windows, not .bat
+            $EXECUTABLE = "$MNENV_ROOT\\installed\\$VERSION-$SOURCE\\bin\\#{executable_name}.cmd"
+          }
+
+          if (-not (Test-Path $EXECUTABLE)) {
+            Write-Error "mnenv: #{executable_name} not installed for version $VERSION (source: $SOURCE)"
+            Write-Error "Install it with: mnenv install $VERSION --source $SOURCE"
+            exit 1
+          }
+
+          & $EXECUTABLE $args
+        SHIM
+      end
+
+      def use_output(version, source)
+        lines = []
+        lines << "$env:METANORMA_VERSION = '#{version}'"
+        lines << "$env:METANORMA_SOURCE = '#{source}'" if source
+        lines << '# Run this in your PowerShell session'
+        lines.join("\n")
+      end
+
+      def config_file
+        File.expand_path('~\Documents\PowerShell\Microsoft.PowerShell_profile.ps1')
+      end
+
+      def windows?
+        true
+      end
+    end
+  end
+end

data/lib/mnenv/shim_manager.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'set'
+require_relative 'shells/factory'
+
+module Mnenv
+  class ShimManager
+    RESOLVER_SCRIPT = File.expand_path('resolver', __dir__).freeze
+
+    attr_reader :shims_dir, :installed_dir
+
+    def initialize(shims_dir: nil, installed_dir: nil)
+      @shims_dir = shims_dir || Paths::SHIMS_DIR
+      @installed_dir = installed_dir || Paths::INSTALLED_DIR
+    end
+
+    def regenerate_all
+      FileUtils.mkdir_p(@shims_dir)
+      FileUtils.mkdir_p(Paths::LIB_DIR)
+
+      # Copy resolver script to mnenv lib directory (for Unix shells)
+      if File.exist?(RESOLVER_SCRIPT)
+        FileUtils.cp(RESOLVER_SCRIPT, File.join(Paths::LIB_DIR, 'resolver'))
+        File.chmod(0o755, File.join(Paths::LIB_DIR, 'resolver'))
+      end
+
+      executables = discover_executables
+
+      executables.each do |exe|
+        create_shims(exe)
+      end
+
+      remove_obsolete_shims(executables)
+    end
+
+    def create_shims(executable_name)
+      # Create shims for all platform-appropriate shells
+      Shells::ShellFactory.platform_shells.each do |shell|
+        create_shim_for_shell(executable_name, shell)
+      end
+    end
+
+    private
+
+    def create_shim_for_shell(executable_name, shell)
+      # For bash, no extension; for PowerShell, .ps1; for CMD, .bat
+      extension = shell.shim_extension
+      shim_name = executable_name + extension
+      shim_path = File.join(@shims_dir, shim_name)
+
+      File.write(shim_path, shell.shim_content(executable_name))
+      File.chmod(0o755, shim_path) unless shell.windows?
+    end
+
+    def discover_executables
+      executables = Set.new
+
+      # Scan installed directories with new naming convention: <version>-<source>
+      Dir.glob(File.join(@installed_dir, '*')).each do |version_dir|
+        next unless File.directory?(version_dir)
+
+        dir_name = File.basename(version_dir)
+        version, source = Paths.parse_version_dir(dir_name)
+        next unless version && source
+
+        case source
+        when 'gemfile'
+          # Discover binstubs from bundle install
+          bin_dir = File.join(version_dir, 'bin')
+          next unless Dir.exist?(bin_dir)
+
+          Dir.glob(File.join(bin_dir, '*')).each do |bin_path|
+            next if File.directory?(bin_path)
+
+            basename = File.basename(bin_path)
+
+            # On Windows, bundler creates both 'command' and 'command.cmd'
+            # Skip .cmd and .bat files - we'll create shims from the base name
+            next if windows? && (basename.end_with?('.cmd') || basename.end_with?('.bat'))
+
+            executables << basename if windows? || File.executable?(bin_path)
+          end
+
+        when 'binary'
+          # Binary installations have a single metanorma binary
+          binary_path = File.join(version_dir, 'metanorma')
+          exe_path = File.join(version_dir, 'metanorma.exe')
+
+          if File.exist?(binary_path) && (File.executable?(binary_path) || windows?)
+            executables << 'metanorma'
+          elsif File.exist?(exe_path)
+            executables << 'metanorma'
+          end
+        end
+      end
+
+      executables.to_a.sort
+    end
+
+    def remove_obsolete_shims(valid_executables)
+      # Build list of valid shim names (with extensions)
+      valid_shim_names = Set.new
+      Shells::ShellFactory.platform_shells.each do |shell|
+        valid_executables.each do |exe|
+          valid_shim_names << exe + shell.shim_extension
+        end
+      end
+
+      Dir.glob(File.join(@shims_dir, '*')).each do |shim_path|
+        next if File.directory?(shim_path)
+
+        shim_name = File.basename(shim_path)
+        File.delete(shim_path) unless valid_shim_names.include?(shim_name)
+      end
+    end
+
+    def windows?
+      RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
+    end
+  end
+end

data/lib/mnenv/snap.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Mnenv
+  module Snap
+    autoload :Fetcher, 'mnenv/snap/fetcher'
+  end
+end

data/lib/mnenv/snap_repository.rb

@@ -8,16 +8,10 @@ module Mnenv
     def version_class = SnapVersion
     def source_name = :snap
 
-    # Override save and save_all to use composite key for Snap
+    # Override cache_version to use composite key for Snap
     # Since same version can have multiple revisions/arch/channels
-    def save(version)
+    def cache_version(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
@@ -55,16 +49,5 @@ module Mnenv
         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/source_registry.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Mnenv
+  # Registry for version sources (gemfile, binary, snap, homebrew, chocolatey)
+  # Enables plugin architecture - new sources just need to register themselves
+  class SourceRegistry
+    class DuplicateSourceError < StandardError; end
+    class UnknownSourceError < StandardError; end
+
+    # Register a new source
+    # @param name [String] the source identifier (e.g., 'gemfile', 'binary')
+    # @param repository [Class] the repository class for this source
+    # @param model [Class] the version model class for this source
+    # @param installer [Class, nil] the installer class (optional)
+    def self.register(name:, repository:, model:, installer: nil)
+      name = name.to_s
+      raise DuplicateSourceError, "Source '#{name}' is already registered" if sources.key?(name)
+
+      sources[name] = {
+        repository: repository,
+        model: model,
+        installer: installer
+      }
+    end
+
+    # Get repository class for a source
+    def self.repository(name)
+      source = sources[name.to_s]
+      raise UnknownSourceError, "Unknown source: #{name}" unless source
+
+      source[:repository]
+    end
+
+    # Get model class for a source
+    def self.model(name)
+      source = sources[name.to_s]
+      raise UnknownSourceError, "Unknown source: #{name}" unless source
+
+      source[:model]
+    end
+
+    # Get installer class for a source
+    def self.installer(name)
+      source = sources[name.to_s]
+      raise UnknownSourceError, "Unknown source: #{name}" unless source
+
+      source[:installer]
+    end
+
+    # Get all registered source names
+    def self.all_names
+      sources.keys.sort
+    end
+
+    # Check if a source is registered
+    def self.registered?(name)
+      sources.key?(name.to_s)
+    end
+
+    # Clear all registrations (useful for testing)
+    def self.clear
+      @sources = nil
+    end
+
+    def self.sources
+      @sources ||= {}
+    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.0'
+  VERSION = '0.1.2'
 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/versions_manager.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'git'
+
+module Mnenv
+  # Manages the local clone of the metanorma/versions repository
+  # Similar to how Homebrew manages its core tap
+  class VersionsManager
+    VERSIONS_REPO = 'https://github.com/metanorma/versions.git'
+    DEFAULT_MNENV_DIR = File.expand_path('~/.mnenv')
+    VERSIONS_DIR = 'versions'
+
+    attr_reader :mnenv_dir, :versions_path
+
+    def initialize(mnenv_dir: nil)
+      @mnenv_dir = mnenv_dir || DEFAULT_MNENV_DIR
+      @versions_path = File.join(@mnenv_dir, VERSIONS_DIR)
+    end
+
+    # Ensure versions repository is cloned and up to date
+    # @param update [Boolean] Force update (git fetch) even if already cloned
+    # @return [String] Path to the versions data directory
+    def ensure_versions_data(update: false)
+      if cloned?
+        update_clone if update || stale?
+      else
+        clone_repo
+      end
+
+      data_path
+    end
+
+    # Check if versions repository is cloned
+    def cloned?
+      File.directory?(File.join(versions_path, '.git'))
+    end
+
+    # Check if the clone is stale (older than 24 hours)
+    def stale?
+      return true unless cloned?
+
+      last_update_file = File.join(versions_path, '.mnenv_last_update')
+      return true unless File.exist?(last_update_file)
+
+      last_update = File.mtime(last_update_file)
+      Time.now - last_update > 86_400 # 24 hours
+    end
+
+    # Path to the data directory within the versions repository
+    def data_path
+      File.join(versions_path, 'data')
+    end
+
+    # Clone the versions repository using the git gem
+    def clone_repo
+      FileUtils.mkdir_p(mnenv_dir)
+      Git.clone(VERSIONS_REPO, VERSIONS_DIR, path: mnenv_dir, depth: 1)
+      touch_update_marker
+    rescue Git::GitExecuteError => e
+      raise "Failed to clone versions repository: #{e.message}"
+    end
+
+    # Update the versions repository using the git gem
+    def update_clone
+      return unless cloned?
+
+      g = Git.open(versions_path)
+      g.fetch
+      g.reset_hard('origin/main')
+      touch_update_marker
+    rescue Git::GitExecuteError => e
+      warn "Warning: Failed to update versions repository: #{e.message}"
+    end
+
+    # Force update the versions repository
+    def update
+      if cloned?
+        update_clone
+      else
+        clone_repo
+      end
+      data_path
+    end
+
+    private
+
+    def touch_update_marker
+      FileUtils.touch(File.join(versions_path, '.mnenv_last_update'))
+    end
+  end
+end

data/lib/mnenv.rb

@@ -3,6 +3,12 @@
 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/cli'

data/mnenv.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   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.homepage      = 'https://github.com/metanorma/mnenv'
   spec.license       = 'MIT'
 
   spec.required_ruby_version = '>= 3.1'
@@ -34,10 +34,13 @@ Gem::Specification.new do |spec|
 
   # Runtime dependencies
   spec.add_dependency 'activesupport'
+  spec.add_dependency 'git'
   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 'octokit'
   spec.add_dependency 'paint'
   spec.add_dependency 'thor', '~> 1.0'
+  spec.add_dependency 'tty-prompt'
 end