makit 0.0.162 → 0.0.163

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f77dc0621ad5f53cc7670638ebd8857ec30daf466babfc8a896b4ef1bdfd5aad
-  data.tar.gz: 28e892048f2393c70d4431891f5352310489c22e4fd594b555f9939f40d52355
+  metadata.gz: 599b26976cbb6cc29f17237f53aa31d334594eb637425b0d534c0eaf53cc215c
+  data.tar.gz: 953a603a359bd3e2535cad44b76eaac2d590761b831b3c3367ff8a67c21f8da0
 SHA512:
-  metadata.gz: 315622470f6f2f86fbb81c8bfecdffdd9ac4efc2fcca625451e4d2b996ba7aa62e64b8e1320873e4efd70767af1a836be5c53b4ede198bc61c88be8bb5a88654
-  data.tar.gz: 0036fd66c4ae5789f7bf3de8eca2305e49f4c6431ce4d508eb51504ec490d0e02ec2d51941d0b071fb815d59ac1c0d5f33aeba6cbdfb1b07109af439ac771add
+  metadata.gz: 95d25294ff19b0a8dfaa611f0a45e471423555b95f1ced18b04b6945b2ece3e5279a9d77df3e0b370d239d4ebf30e87cc0f91598c0e0a33ae1ca16b6b4ecd9f1
+  data.tar.gz: 2fd32bc4994feb7492182ad20becea5f3a4bcb0d946e6bf939925a3921986c455abb0bc1b3378d75e6318b311c534e629af30824c17764e67fbcd5b89e447932

data/lib/makit/dotnet/cli.rb

@@ -30,6 +30,161 @@ module Makit
         end
       end
 
+      # Installs a .NET global tool if it's not already installed
+      #
+      # @param tool_name [String] The name of the tool to install (e.g., "docfx", "dotnet-outdated-tool")
+      # @return [Boolean] true if the tool was installed or already exists, false if installation failed
+      def self.install_global_tool(tool_name)
+        raise ArgumentError, "tool_name is required" if tool_name.nil? || tool_name.strip.empty?
+
+        tool_name = tool_name.strip
+
+        # Check if tool is already installed
+        # Parse the output to find exact tool name matches
+        list_output = `dotnet tool list --global 2>&1`
+        if $CHILD_STATUS.success?
+          # The output format is typically:
+          # Package Id      Version      Commands
+          # ----------------------------------------
+          # docfx           2.x.x        docfx
+          # Parse lines to find exact tool name matches
+          installed = list_output.lines.any? do |line|
+            # Match tool name at the start of a line (after optional whitespace)
+            # or as a word boundary to avoid substring matches
+            line.strip.split(/\s+/).first == tool_name
+          end
+
+          if installed
+            Makit::Logging.default_logger.info("Global tool '#{tool_name}' is already installed")
+            return true
+          end
+        end
+
+        # Install the tool
+        Makit::Logging.default_logger.info("Installing global tool '#{tool_name}'...")
+        "dotnet tool install --global #{tool_name}".run
+        $CHILD_STATUS.success?
+      end
+
+      # Gets the currently installed version of a global tool
+      #
+      # @param tool_name [String] The name of the tool
+      # @return [String, nil] The installed version, or nil if not installed
+      def self.get_installed_tool_version(tool_name)
+        list_output = `dotnet tool list --global 2>&1`
+        return nil unless $CHILD_STATUS.success?
+
+        # Skip header lines
+        list_output.lines.each do |line|
+          line_stripped = line.strip
+          next if line_stripped.empty?
+          next if line_stripped.start_with?("Package") || line_stripped.start_with?("-")
+          
+          # Split by whitespace - columns are: Package Id, Version, Commands
+          parts = line_stripped.split(/\s+/)
+          next if parts.empty?
+          
+          # Match tool name at the start of the line
+          if parts.first == tool_name && parts.length >= 2
+            # Version is the second column
+            return parts[1]
+          end
+        end
+
+        nil
+      end
+      private_class_method :get_installed_tool_version
+
+      # Gets the latest available version of a tool from NuGet
+      #
+      # @param tool_name [String] The name of the tool
+      # @return [String, nil] The latest version, or nil if not found
+      def self.get_latest_tool_version(tool_name)
+        search_output = `dotnet tool search #{tool_name} --take 1 2>&1`
+        return nil unless $CHILD_STATUS.success?
+
+        # Parse output format:
+        # Package ID      Latest Version      Authors                               Downloads      Verified
+        # -------------------------------------------------------------------------------------------------
+        # docfx           2.78.4              .NET Foundation and Contributors      4091347        x
+        search_output.lines.each do |line|
+          line_stripped = line.strip
+          next if line_stripped.empty?
+          next if line_stripped.start_with?("Package") || line_stripped.start_with?("-")
+          
+          # Split by whitespace - columns are: Package ID, Latest Version, Authors, Downloads, Verified
+          parts = line_stripped.split(/\s+/)
+          next if parts.empty?
+          
+          # Match tool name at the start of the line
+          if parts.first == tool_name && parts.length >= 2
+            # Latest Version is the second column
+            return parts[1]
+          end
+        end
+
+        nil
+      end
+      private_class_method :get_latest_tool_version
+
+      # Updates a .NET global tool to the latest version if a newer version is available
+      #
+      # If a newer version is available, the tool will be uninstalled and then reinstalled
+      # to ensure the latest version is installed.
+      #
+      # @param tool_name [String] The name of the tool to update (e.g., "docfx", "dotnet-outdated-tool")
+      # @return [Boolean] true if the tool was updated or already at latest version, false if update failed
+      def self.update_global_tool(tool_name)
+        raise ArgumentError, "tool_name is required" if tool_name.nil? || tool_name.strip.empty?
+
+        tool_name = tool_name.strip
+
+        # Get currently installed version
+        installed_version = get_installed_tool_version(tool_name)
+        
+        if installed_version.nil?
+          Makit::Logging.default_logger.info("Global tool '#{tool_name}' is not installed, installing...")
+          return install_global_tool(tool_name)
+        end
+
+        # Get latest available version
+        latest_version = get_latest_tool_version(tool_name)
+        
+        if latest_version.nil?
+          Makit::Logging.default_logger.warn("Could not determine latest version for '#{tool_name}', skipping update")
+          return false
+        end
+
+        # Compare versions
+        begin
+          versions_to_compare = [installed_version, latest_version]
+          highest_version = Makit::Version.get_highest_version(versions_to_compare)
+          
+          if highest_version == installed_version
+            Makit::Logging.default_logger.info("Global tool '#{tool_name}' is already at latest version (#{installed_version})")
+            return true
+          end
+        rescue => e
+          Makit::Logging.default_logger.warn("Could not compare versions for '#{tool_name}': #{e.message}, attempting update anyway")
+        end
+
+        # Newer version available - uninstall and reinstall
+        Makit::Logging.default_logger.info("Updating global tool '#{tool_name}' from #{installed_version} to #{latest_version}...")
+        
+        # Uninstall the tool
+        Makit::Logging.default_logger.info("Uninstalling global tool '#{tool_name}'...")
+        "dotnet tool uninstall --global #{tool_name}".run
+        unless $CHILD_STATUS.success?
+          Makit::Logging.default_logger.error("Failed to uninstall global tool '#{tool_name}'")
+          return false
+        end
+
+        # Install the latest version
+        Makit::Logging.default_logger.info("Installing global tool '#{tool_name}' version #{latest_version}...")
+        "dotnet tool install --global #{tool_name}".run
+        $CHILD_STATUS.success?
+      end
+
       #
       # generate docs/DotNet.md
       #

data/lib/makit/dotnet.rb

@@ -98,5 +98,13 @@ module Makit
     def self.generate_docs
       CLI.generate_docs
     end
+
+    def self.install_global_tool(tool_name)
+      CLI.install_global_tool(tool_name)
+    end
+
+    def self.update_global_tool(tool_name)
+      CLI.update_global_tool(tool_name)
+    end
   end
 end

data/lib/makit/nuget.rb

@@ -239,5 +239,191 @@ module Makit
       # Add the source
       add_source(name, url, username: username, password: password, store_password_in_clear_text: store_password_in_clear_text)
     end
+
+    # Migrates packages from one NuGet source to another, matching a pattern
+    #
+    # For local directory feeds, packages are found by scanning the directory structure:
+    # {source_path}/{package_name}/{version}/{package_name}.{version}.nupkg
+    #
+    # @param source_name [String] The name of the source to migrate from
+    # @param package_pattern [String] The package name pattern to match (e.g., "rep*", "MyPackage.*")
+    # @param destination_name [String] The name of the destination source
+    # @return [Integer] The number of packages migrated, or -1 if an error occurred
+    def self.migrate_packages(source_name, package_pattern, destination_name)
+      raise ArgumentError, "source_name is required" if source_name.nil? || source_name.strip.empty?
+      raise ArgumentError, "package_pattern is required" if package_pattern.nil? || package_pattern.strip.empty?
+      raise ArgumentError, "destination_name is required" if destination_name.nil? || destination_name.strip.empty?
+
+      source_name = source_name.strip
+      package_pattern = package_pattern.strip
+      destination_name = destination_name.strip
+
+      # Get source information
+      sources = list_sources
+      source_info = sources.find { |s| s[:name] == source_name }
+      destination_info = sources.find { |s| s[:name] == destination_name }
+
+      unless source_info
+        Makit::Logging.default_logger.error("Source '#{source_name}' not found")
+        return -1
+      end
+
+      unless destination_info
+        Makit::Logging.default_logger.error("Destination source '#{destination_name}' not found")
+        return -1
+      end
+
+      source_path = source_info[:url]
+      destination_path = destination_info[:url]
+
+      # Check if sources are local directory feeds (not URLs)
+      unless source_path && !source_path.match?(/^https?:\/\//)
+        Makit::Logging.default_logger.error("Source '#{source_name}' is not a local directory feed (URL: #{source_path})")
+        return -1
+      end
+
+      unless destination_path && !destination_path.match?(/^https?:\/\//)
+        Makit::Logging.default_logger.error("Destination source '#{destination_name}' is not a local directory feed (URL: #{destination_path})")
+        return -1
+      end
+
+      # Expand and normalize the source path
+      source_path = File.expand_path(source_path)
+      destination_path = File.expand_path(destination_path)
+
+      # Ensure source directory exists
+      unless Dir.exist?(source_path)
+        Makit::Logging.default_logger.error("Source directory does not exist: #{source_path}")
+        return -1
+      end
+
+      Makit::Logging.default_logger.info("Searching for packages matching '#{package_pattern}' in source '#{source_name}' (#{source_path})")
+
+      # Ensure destination directory exists
+      FileUtils.mkdir_p(destination_path) unless Dir.exist?(destination_path)
+
+      # Find all .nupkg files matching the pattern
+      # Simply search recursively for all .nupkg files and match package names
+      matching_packages = []
+      
+      # Glob for all .nupkg files recursively in the source directory
+      Dir.glob(File.join(source_path, "**", "*.nupkg")) do |nupkg_file|
+        # Extract package name from the file path
+        # Path structure is typically: {source_path}/{package_name}/{version}/{package_name}.{version}.nupkg
+        relative_path = nupkg_file.sub(/^#{Regexp.escape(source_path)}[\/\\]?/, "")
+        path_parts = relative_path.split(/[\/\\]/)
+        
+        # Get package name from directory structure (first directory after source_path)
+        package_name = path_parts.length >= 1 ? path_parts[0] : nil
+        
+        # If we can't get it from path, try to extract from filename
+        if package_name.nil? || package_name.empty?
+          filename = File.basename(nupkg_file, ".nupkg")
+          # Try to extract package name by removing version suffix (e.g., "1.2.3" or "1.2.3-beta")
+          if filename.match?(/^(.+?)\.(\d+\.\d+.*)$/)
+            package_name = $1
+          else
+            package_name = filename
+          end
+        end
+        
+        # Check if package name matches pattern
+        if package_name && File.fnmatch?(package_pattern, package_name, File::FNM_DOTMATCH)
+          # Extract version from path (second directory) or from filename
+          version = path_parts.length >= 2 ? path_parts[1] : nil
+          
+          # If we couldn't extract version from path, try from filename
+          if version.nil? || version.empty?
+            filename = File.basename(nupkg_file, ".nupkg")
+            if filename.match?(/^.+?\.(\d+\.\d+.*)$/)
+              version = $1
+            else
+              version = "unknown"
+            end
+          end
+          
+          matching_packages << {
+            package_name: package_name,
+            version: version,
+            nupkg_path: nupkg_file
+          }
+        end
+      end
+
+      if matching_packages.empty?
+        Makit::Logging.default_logger.info("No packages found matching pattern '#{package_pattern}' in source '#{source_name}'")
+        return 0
+      end
+
+      Makit::Logging.default_logger.info("Found #{matching_packages.length} package(s) matching pattern '#{package_pattern}' in source '#{source_name}'")
+
+      # Migrate each package
+      migrated_count = 0
+      failed_count = 0
+
+      matching_packages.each do |package_info|
+        package_name = package_info[:package_name]
+        version = package_info[:version]
+        nupkg_path = package_info[:nupkg_path]
+
+        Makit::Logging.default_logger.info("Migrating #{package_name}.#{version} from '#{source_name}' to '#{destination_name}'...")
+
+        # Determine target path in organized structure: {package_name}/{version}/{package_name}.{version}.nupkg
+        # Use lowercase for directory structure to match NuGet conventions
+        target_package_dir = File.join(destination_path, package_name.downcase, version)
+        target_package_path = File.join(target_package_dir, File.basename(nupkg_path).downcase)
+        
+        if File.exist?(target_package_path)
+          Makit::Logging.default_logger.info("  Package already exists in destination, skipping: #{package_name}.#{version}")
+          migrated_count += 1
+          next
+        end
+
+        # For local directory feeds, use 'nuget add' which automatically organizes packages
+        # into the hierarchical structure: {packageID}/{version}/packageID.version.nupkg
+        # This is the recommended command for local feeds as it handles organization and metadata
+        stdout, stderr, status = Open3.capture3("nuget", "add", nupkg_path, "-Source", destination_path)
+
+        if status.success?
+          Makit::Logging.default_logger.info("  Successfully migrated and organized #{package_name}.#{version}")
+          migrated_count += 1
+        else
+          # Fallback to dotnet nuget push if nuget.exe is not available
+          # Check if nuget.exe exists, otherwise try dotnet nuget push
+          nuget_exe = Makit::Environment.which("nuget")
+          if nuget_exe.nil? || nuget_exe.empty?
+            Makit::Logging.default_logger.info("  nuget.exe not found, falling back to dotnet nuget push")
+            
+            # Manually organize package into proper directory structure
+            Makit::Logging.default_logger.info("  Organizing package into directory structure: #{target_package_dir}")
+            FileUtils.mkdir_p(target_package_dir)
+            FileUtils.cp(nupkg_path, target_package_path)
+            
+            # Push using dotnet nuget push from the organized location
+            stdout, stderr, status = Open3.capture3("dotnet", "nuget", "push", target_package_path, "--source", destination_path)
+            
+            if status.success?
+              Makit::Logging.default_logger.info("  Successfully migrated and organized #{package_name}.#{version}")
+              migrated_count += 1
+            else
+              Makit::Logging.default_logger.warn("  Package copied to organized structure but dotnet nuget push failed: #{stderr}")
+              Makit::Logging.default_logger.warn("  Package is available at #{target_package_path} but may need manual indexing")
+              migrated_count += 1
+            end
+          else
+            Makit::Logging.default_logger.error("  Failed to migrate #{package_name}.#{version}: #{stderr}")
+            failed_count += 1
+          end
+        end
+      end
+
+      if failed_count > 0
+        Makit::Logging.default_logger.warn("Migration completed with #{failed_count} failure(s). #{migrated_count} package(s) migrated successfully.")
+      else
+        Makit::Logging.default_logger.info("Successfully migrated #{migrated_count} package(s) from '#{source_name}' to '#{destination_name}'")
+      end
+
+      migrated_count
+    end
   end
 end

data/lib/makit/version.rb

@@ -2,7 +2,7 @@
 
 module Makit
   # Static version for now to avoid circular dependency issues
-  #VERSION = "0.0.162"
+  #VERSION = "0.0.163"
 
   # Version management utilities for various file formats
   #

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: makit
 version: !ruby/object:Gem::Version
-  version: 0.0.162
+  version: 0.0.163
 platform: ruby
 authors:
 - Lou Parslow