makit 0.0.162 → 0.0.164

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f77dc0621ad5f53cc7670638ebd8857ec30daf466babfc8a896b4ef1bdfd5aad
-  data.tar.gz: 28e892048f2393c70d4431891f5352310489c22e4fd594b555f9939f40d52355
+  metadata.gz: 5aa415801dae9c081791596f59c00947878f6ee7d76d3bb7515f6ea8e2a8e958
+  data.tar.gz: 12983cf08ef21f336c22bf3903a0e336acc0860cc201f55c5c742814c4e1c8e7
 SHA512:
-  metadata.gz: 315622470f6f2f86fbb81c8bfecdffdd9ac4efc2fcca625451e4d2b996ba7aa62e64b8e1320873e4efd70767af1a836be5c53b4ede198bc61c88be8bb5a88654
-  data.tar.gz: 0036fd66c4ae5789f7bf3de8eca2305e49f4c6431ce4d508eb51504ec490d0e02ec2d51941d0b071fb815d59ac1c0d5f33aeba6cbdfb1b07109af439ac771add
+  metadata.gz: 79310ac260f739a81bb2a2fec375133a6e61635a0b936b27fc1f3d223755c1024e76f6bca5e5134b008adf700cf2808bf54672647f7fdaede6fb9b4094ed7dee
+  data.tar.gz: 3677481dfedddfbd200f5adc024477ea74fc8044c9caf0f643d913e0b868a633c4ad90438469b11f7e2dcc5c9a1fc8112aaa442457f1a95019ec6c1165103f61

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,216 @@ 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]
+
+      # Source must be a local directory feed (not a URL)
+      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
+
+      # Expand and normalize the source path
+      source_path = File.expand_path(source_path)
+      
+      # Destination can be either local directory feed or remote feed (Azure DevOps, NuGet.org, etc.)
+      is_remote_destination = destination_path && destination_path.match?(/^https?:\/\//)
+
+      # 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})")
+      Makit::Logging.default_logger.info("Destination: #{destination_name} (#{destination_path}) - #{is_remote_destination ? 'Remote feed' : 'Local directory feed'}")
+
+      # Ensure destination directory exists (only for local feeds)
+      unless is_remote_destination
+        FileUtils.mkdir_p(destination_path) unless Dir.exist?(destination_path)
+      end
+
+      # 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}'...")
+
+        if is_remote_destination
+          # For remote feeds (Azure DevOps, NuGet.org, etc.), use dotnet nuget push
+          # Azure DevOps requires --api-key az (placeholder) and --skip-duplicate
+          Makit::Logging.default_logger.info("  Pushing #{package_name}.#{version} to remote feed...")
+          
+          args = ["dotnet", "nuget", "push", nupkg_path, "--source", destination_path, "--skip-duplicate"]
+          
+          # For Azure DevOps feeds, add --api-key az (required placeholder)
+          if destination_path.include?("dev.azure.com") || destination_path.include?("pkgs.dev.azure.com")
+            args << "--api-key" << "az"
+          end
+          
+          stdout, stderr, status = Open3.capture3(*args)
+          
+          if status.success?
+            Makit::Logging.default_logger.info("  Successfully migrated #{package_name}.#{version} to remote feed")
+            migrated_count += 1
+          else
+            # Check if it's a duplicate (which is okay with --skip-duplicate)
+            if stderr.include?("already exists") || stderr.include?("duplicate")
+              Makit::Logging.default_logger.info("  Package already exists in destination, skipping: #{package_name}.#{version}")
+              migrated_count += 1
+            else
+              Makit::Logging.default_logger.error("  Failed to migrate #{package_name}.#{version}: #{stderr}")
+              failed_count += 1
+            end
+          end
+        else
+          # For local directory feeds, use 'nuget add' which automatically organizes packages
+          # into the hierarchical structure: {packageID}/{version}/packageID.version.nupkg
+          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
+          
+          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
+            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
+      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.164"
 
   # 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.164
 platform: ruby
 authors:
 - Lou Parslow