makit 0.0.158 → 0.0.161

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ef7398a9e375d733986e441439fe559ef13ccf112013bcf17c453099a963232
-  data.tar.gz: 60467798aa0a1d29a802a9f164e4b91852f35824f3f9d8f24b3b9b85c80a967a
+  metadata.gz: 816fae3f93930ba4fd38d5862f5b716ef7f367f0b15718e3cbef6b825415fd8f
+  data.tar.gz: 21e8e83a05ef9ce2ba3748a8ed824b85eb6e436693354ea8ccd414bddce4d0e6
 SHA512:
-  metadata.gz: f73335164b833168eaf3e11770aa3f5eba1a7d563a5a8d98dd7e93e5962826e8e71a4f39c337e6e5eca8c1a9f50cec83f0f9b34c7c14c02cb14ceb0b8e7961c6
-  data.tar.gz: 9198e9f1b17101964bc405bad3deb9e253a00d71c3d89935f35cf194dbc082fbeb52e362ff8498975c5544ba04b540b64cc3e32683d514abaa34e42d49c5743b
+  metadata.gz: 0f80e9b880100024ccc5411292a206bd5ecd504c86f57ed0c2c90ba9c3a1e1d849f0ccc1044b00f5eedd1b2cf81d6a2c12565becabfee7426da2144a7e924402
+  data.tar.gz: a3af55207d9e4e018c15f1659cc3dc4ff1727b4d9098da7c35f36ccae2745ad051828166be517e57e98c02c4fd79b94c91924764002127b6f4db485d015b90d3

data/lib/makit/git/cli.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "open3"
+
 # This module provides classes for the Makit gem.
 module Makit
   class Git
@@ -22,11 +24,15 @@ module Makit
         return unless Repository.git_repo? && !Repository.detached
 
         "git pull".try
+        # Fetch tags explicitly to ensure we have the latest remote tag information
+        "git fetch --tags origin".try
         "git push origin".try
         
         # Check which tags need to be pushed (exist locally but not remotely)
         local_tags = `git tag -l`.strip.split("\n").reject(&:empty?)
-        remote_tags_output = `git ls-remote --tags origin 2>/dev/null`.strip
+        # Use Open3 for cross-platform stderr handling (Windows doesn't support 2>/dev/null)
+        remote_tags_output, _stderr, _status = Open3.capture3("git", "ls-remote", "--tags", "origin")
+        remote_tags_output = remote_tags_output.strip
         remote_tags = if remote_tags_output.empty?
           []
         else
@@ -43,9 +49,28 @@ module Makit
         if tags_to_push.empty?
           Makit::Logging.default_logger.info("All tags already exist on remote, skipping tag push")
         else
-          Makit::Logging.default_logger.info("Pushing #{tags_to_push.length} tag(s) to remote: #{tags_to_push.join(', ')}")
-          tags_to_push.each do |tag|
-            "git push origin #{tag}".try
+          # Limit to 5 tags per sync to avoid overwhelming the remote
+          tags_to_push_limited = tags_to_push.first(5)
+          remaining_count = tags_to_push.length - tags_to_push_limited.length
+          
+          if remaining_count.positive?
+            Makit::Logging.default_logger.info("Pushing #{tags_to_push_limited.length} of #{tags_to_push.length} tag(s) to remote (limited to 5 per sync): #{tags_to_push_limited.join(', ')}")
+            Makit::Logging.default_logger.info("#{remaining_count} tag(s) will be pushed in subsequent sync operations")
+          else
+            Makit::Logging.default_logger.info("Pushing #{tags_to_push_limited.length} tag(s) to remote: #{tags_to_push_limited.join(', ')}")
+          end
+          
+          tags_to_push_limited.each do |tag|
+            # Double-check that tag doesn't exist on remote before pushing
+            # This prevents pushing tags that were added to remote between the ls-remote check and now
+            # Use Open3 for cross-platform stderr handling (Windows doesn't support 2>/dev/null)
+            remote_tag_check, _stderr, _status = Open3.capture3("git", "ls-remote", "--tags", "origin", "refs/tags/#{tag}")
+            remote_tag_check = remote_tag_check.strip
+            if remote_tag_check.empty?
+              "git push origin #{tag}".try
+            else
+              Makit::Logging.default_logger.info("Tag #{tag} already exists on remote, skipping push")
+            end
           end
         end
       end

data/lib/makit/nuget_cache.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "open3"
+
+module Makit
+  module NugetCache
+    class Error < StandardError; end
+
+    # Purges a package (and optionally a version) from the NuGet global packages cache.
+    #
+    # Examples:
+    #   Makit::NugetCache.purge(package_id: "Newtonsoft.Json")
+    #   Makit::NugetCache.purge(package_id: "Newtonsoft.Json", version: "13.0.3")
+    #
+    # Returns a Hash with keys:
+    #   :global_packages_dir, :package_dir, :target_dir, :purged, :reason (if not purged)
+    #
+    def self.purge(package_id:, version: nil, dotnet: "dotnet", dry_run: false)
+      raise ArgumentError, "package_id is required" if package_id.to_s.strip.empty?
+
+      global_dir = resolve_global_packages_dir(dotnet: dotnet)
+      package_dir = File.join(global_dir, normalize_package_id(package_id))
+
+      target_dir =
+        if version && !version.to_s.strip.empty?
+          File.join(package_dir, version.to_s.strip)
+        else
+          package_dir
+        end
+
+      result = {
+        global_packages_dir: global_dir,
+        package_dir: package_dir,
+        target_dir: target_dir,
+        purged: false
+      }
+
+      unless Dir.exist?(target_dir)
+        result[:reason] = "Target directory does not exist"
+        return result
+      end
+
+      if dry_run
+        result[:reason] = "dry_run"
+        return result
+      end
+
+      assert_within!(target_dir, global_dir)
+
+      FileUtils.rm_rf(target_dir)
+      result[:purged] = true
+      result
+    rescue Error, ArgumentError => e
+      result ||= {}
+      result[:purged] = false
+      result[:reason] = e.message
+      result
+    end
+
+    # -----------------------
+    # Internals
+    # -----------------------
+
+    def self.normalize_package_id(package_id)
+      # NuGet global-packages directory uses lowercase package IDs on disk
+      package_id.to_s.strip.downcase
+    end
+    private_class_method :normalize_package_id
+
+    def self.resolve_global_packages_dir(dotnet:)
+      stdout, _stderr, status =
+        Open3.capture3(dotnet.to_s, "nuget", "locals", "global-packages", "--list")
+
+      if status.success?
+        path = parse_global_packages_dir(stdout)
+        return path if path && !path.empty?
+      end
+
+      # Fallback 1: NUGET_PACKAGES environment variable
+      env_path = ENV["NUGET_PACKAGES"]
+      return File.expand_path(env_path) if env_path && !env_path.strip.empty?
+
+      # Fallback 2: conventional default
+      home = Dir.home
+      raise Error, "Unable to resolve home directory" if home.nil? || home.strip.empty?
+
+      File.join(home, ".nuget", "packages")
+    rescue Errno::ENOENT
+      # dotnet not available; fall back to env/default
+      env_path = ENV["NUGET_PACKAGES"]
+      return File.expand_path(env_path) if env_path && !env_path.strip.empty?
+
+      File.join(Dir.home, ".nuget", "packages")
+    end
+    private_class_method :resolve_global_packages_dir
+
+    def self.parse_global_packages_dir(output)
+      line = output.to_s.lines.find { |l| l.strip.start_with?("global-packages:") }
+      return nil unless line
+
+      path = line.split("global-packages:", 2).last.to_s.strip
+      return nil if path.empty?
+
+      File.expand_path(path)
+    end
+    private_class_method :parse_global_packages_dir
+
+    def self.assert_within!(target_dir, root_dir)
+      target = File.expand_path(target_dir)
+      root   = File.expand_path(root_dir)
+
+      if root.strip.empty? || root == File::SEPARATOR
+        raise Error, "Refusing to purge: invalid global packages directory '#{root_dir}'"
+      end
+
+      unless target.start_with?(root.end_with?(File::SEPARATOR) ? root : "#{root}#{File::SEPARATOR}")
+        raise Error, "Refusing to purge '#{target}': not within global packages dir '#{root}'"
+      end
+    end
+    private_class_method :assert_within!
+  end
+end

data/lib/makit/port_utility.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Makit
+  module PortUtility
+    class Error < StandardError; end
+
+    # Ensures a port is free by killing any process using it.
+    #
+    # Examples:
+    #   Makit::PortUtility.ensure_port_free(5261)
+    #   Makit::PortUtility.ensure_port_free(5261, verbose: true)
+    #
+    # Returns true if the port is now free, false if it couldn't be freed.
+    #
+    def self.ensure_port_free(port, verbose: false)
+      raise ArgumentError, "port must be a positive integer" unless port.is_a?(Integer) && port > 0
+
+      return true unless port_in_use?(port)
+
+      puts "Port #{port} is in use. Attempting to free it..." if verbose
+
+      killed = kill_process_on_port(port, verbose: verbose)
+
+      if killed
+        # Wait a moment for the port to be released
+        sleep(1)
+        # Verify port is now free
+        unless port_in_use?(port)
+          puts "Port #{port} is now free." if verbose
+          return true
+        else
+          puts "Warning: Port #{port} is still in use after killing process." if verbose
+          return false
+        end
+      else
+        puts "Warning: Could not kill process on port #{port}." if verbose
+        return false
+      end
+    rescue Error, ArgumentError => e
+      puts "Error freeing port #{port}: #{e.message}" if verbose
+      false
+    end
+
+    # -----------------------
+    # Internals
+    # -----------------------
+
+    def self.port_in_use?(port)
+      if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+        # Windows: Use netstat
+        stdout, _stderr, status = Open3.capture3("netstat", "-ano")
+        return false unless status.success?
+        stdout.lines.any? { |line| line.include?(":#{port}") && line.include?("LISTENING") }
+      else
+        # Unix/macOS: Use lsof
+        stdout, _stderr, status = Open3.capture3("lsof", "-ti:#{port}")
+        status.success? && !stdout.strip.empty?
+      end
+    rescue Errno::ENOENT
+      # Command not found - assume port is not in use
+      false
+    end
+    private_class_method :port_in_use?
+
+    def self.kill_process_on_port(port, verbose: false)
+      if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+        # Windows: Use netstat to find PID, then taskkill
+        stdout, _stderr, status = Open3.capture3("netstat", "-ano")
+        return false unless status.success?
+
+        pids = []
+        stdout.lines.each do |line|
+          if line.include?(":#{port}") && line.include?("LISTENING")
+            parts = line.split
+            pid = parts.last
+            pids << pid if pid && pid.match?(/^\d+$/)
+          end
+        end
+
+        killed_any = false
+        pids.uniq.each do |pid|
+          begin
+            stdout, _stderr, status = Open3.capture3("taskkill", "/F", "/PID", pid)
+            if status.success?
+              puts "Killed process #{pid} on port #{port}" if verbose
+              killed_any = true
+            end
+          rescue Errno::ENOENT
+            # taskkill not found
+            return false
+          end
+        end
+
+        killed_any
+      else
+        # Unix/macOS: Use lsof to find PID, then kill
+        stdout, _stderr, status = Open3.capture3("lsof", "-ti:#{port}")
+        return false unless status.success?
+        return true if stdout.strip.empty? # Port is already free
+
+        pids = stdout.strip.split("\n").map(&:strip).reject(&:empty?)
+        return false if pids.empty?
+
+        killed_any = false
+        pids.each do |pid|
+          begin
+            stdout, _stderr, status = Open3.capture3("kill", "-9", pid)
+            if status.success?
+              puts "Killed process #{pid} on port #{port}" if verbose
+              killed_any = true
+            end
+          rescue Errno::ENOENT
+            # kill not found
+            return false
+          end
+        end
+
+        killed_any
+      end
+    rescue Errno::ENOENT
+      # Command not found
+      false
+    end
+    private_class_method :kill_process_on_port
+  end
+end

data/lib/makit/tasks/update.rb

@@ -6,12 +6,15 @@ task :update do
   # are there any *.sln files?
   Dir.glob("**/*.sln").each do |sln_file|
     "dotnet sln migrate #{sln_file}".run
-    FileUtils.rm_f(sln_file) if File.exist?(sln_file.gsub(".sln", ".slnx"))
+    #FileUtils.rm_f(sln_file) if File.exist?(sln_file.gsub(".sln", ".slnx"))
   end
   "dotnet tool update --global dotnet-outdated-tool".run
-  Dir.glob("**/*.slnx").each do |slnx_file|
-    "dotnet outdated #{slnx_file} --upgrade:Auto".run
-  end
+  #Dir.glob("**/*.slnx").each do |slnx_file|
+  #  "dotnet outdated #{slnx_file} --upgrade:Auto".run
+  #end
+  #Dir.glob("**/*.sln").each do |sln_file|
+  #  "dotnet outdated #{sln_file} --upgrade:Auto".run
+  #end
   Dir.glob("**/*.csproj").each do |csproj_file|
     "dotnet outdated #{csproj_file} --upgrade:Auto".run
   end

data/lib/makit/version.rb

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

data/lib/makit/zip_utility.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "find"
+require "zip"
+
+module Makit
+  module ZipUtility
+    class Error < StandardError; end
+
+    # Creates a zip file from a directory, preserving directory structure.
+    # Excludes files matching the exclude_pattern from the archive.
+    #
+    # Examples:
+    #   Makit::ZipUtility.create_from_directory(
+    #     source_dir: "artifacts/Musco.Aim3.AspNet.Host",
+    #     zip_path: "artifacts/Musco.Aim3.AspNet.Host.zip"
+    #   )
+    #   Makit::ZipUtility.create_from_directory(
+    #     source_dir: "artifacts/build",
+    #     zip_path: "artifacts/build.zip",
+    #     exclude_pattern: "*.{pdb,log}"
+    #   )
+    #
+    # @param source_dir [String] The directory to zip
+    # @param zip_path [String] The output zip file path
+    # @param exclude_pattern [String] File pattern to exclude (default: "*.pdb")
+    #   Supports glob patterns like "*.pdb", "*.{pdb,log}", "**/*.tmp"
+    # @raise [Error] If source directory doesn't exist or zip creation fails
+    def self.create_from_directory(source_dir:, zip_path:, exclude_pattern: "*.pdb")
+      source_dir = File.expand_path(source_dir)
+      zip_path = File.expand_path(zip_path)
+
+      unless Dir.exist?(source_dir)
+        raise Error, "Source directory does not exist: #{source_dir}"
+      end
+
+      # Delete existing zip if it exists
+      File.delete(zip_path) if File.exist?(zip_path)
+
+      # Use RubyZip gem (cross-platform, no shell commands needed)
+      create_zip_with_rubyzip(source_dir, zip_path, exclude_pattern)
+
+      unless File.exist?(zip_path)
+        raise Error, "Failed to create zip file: #{zip_path}"
+      end
+
+      zip_path
+    end
+
+    # -----------------------
+    # Internals
+    # -----------------------
+
+    def self.create_zip_with_rubyzip(source_dir, zip_path, exclude_pattern)
+      source_dir_normalized = File.expand_path(source_dir)
+      
+      ::Zip::File.open(zip_path, ::Zip::File::CREATE) do |zipfile|
+        Find.find(source_dir_normalized) do |file_path|
+          next unless File.file?(file_path)
+          
+          # Get relative path from source directory (normalize separators)
+          relative_path = file_path.sub(/^#{Regexp.escape(source_dir_normalized)}[\/\\]?/, "")
+          # Normalize to forward slashes for zip file entries (zip standard)
+          relative_path = relative_path.gsub("\\", "/")
+          
+          # Skip if file matches exclude pattern
+          next if should_exclude?(relative_path, exclude_pattern)
+          
+          # Add file to zip with relative path
+          zipfile.add(relative_path, file_path)
+        end
+      end
+    rescue ::Zip::Error => e
+      raise Error, "Failed to create zip file: #{e.message}"
+    rescue StandardError => e
+      raise Error, "Unexpected error creating zip file: #{e.message}"
+    end
+    private_class_method :create_zip_with_rubyzip
+
+    def self.should_exclude?(file_path, exclude_pattern)
+      return false if exclude_pattern.nil? || exclude_pattern.strip.empty?
+      
+      # Support multiple patterns separated by commas
+      patterns = exclude_pattern.split(",").map(&:strip)
+      
+      patterns.any? do |pattern|
+        # Use File.fnmatch for glob pattern matching
+        # Match against just the filename or full relative path
+        filename = File.basename(file_path)
+        File.fnmatch?(pattern, filename, File::FNM_PATHNAME | File::FNM_DOTMATCH) ||
+          File.fnmatch?(pattern, file_path, File::FNM_PATHNAME | File::FNM_DOTMATCH)
+      end
+    end
+    private_class_method :should_exclude?
+  end
+end

data/lib/makit.rb

@@ -88,6 +88,9 @@ require_relative "makit/mp/string_mp"
 require_relative "makit/git"
 require_relative "makit/protoc"
 require_relative "makit/zip"
+require_relative "makit/nuget_cache"
+require_relative "makit/port_utility"
+require_relative "makit/zip_utility"
 
 # Load services modules
 # Note: RepositoryManager intermediate classes removed after Phase 4 cleanup

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: makit
 version: !ruby/object:Gem::Version
-  version: 0.0.158
+  version: 0.0.161
 platform: ruby
 authors:
 - Lou Parslow
@@ -341,9 +341,11 @@ files:
 - lib/makit/mp/project_mp.rb
 - lib/makit/mp/string_mp.rb
 - lib/makit/nuget.rb
+- lib/makit/nuget_cache.rb
 - lib/makit/podman/podman.rb
 - lib/makit/podman/podman_service_impl.rb
 - lib/makit/port.rb
+- lib/makit/port_utility.rb
 - lib/makit/process.rb
 - lib/makit/protoc.rb
 - lib/makit/rake.rb
@@ -404,6 +406,7 @@ files:
 - lib/makit/wix.rb
 - lib/makit/yaml.rb
 - lib/makit/zip.rb
+- lib/makit/zip_utility.rb
 homepage: https://github.com/yourusername/makit
 licenses:
 - MIT