makit 0.0.99 → 0.0.111

data/lib/makit/cli/utility_commands.rb

@@ -0,0 +1,521 @@
+# frozen_string_literal: true
+
+require "English"
+require "clamp"
+require "fileutils"
+
+module Makit
+  module Cli
+    # Consolidated utility commands
+    # Combines: nuget_cache and other utility functionality
+    class UtilityCommand < Clamp::Command
+      self.description = <<~DESC
+        Utility commands for system maintenance and development tools.
+
+        Available operations:
+          nuget-cache - Manage NuGet package cache
+          system-info - Display system and environment information
+      DESC
+    end
+
+    # Manage NuGet package cache
+    class NugetCacheCommand < Clamp::Command
+      self.description = <<~DESC
+        Manage NuGet package cache and troubleshoot package issues.
+
+        Examples:
+          makit utility nuget-cache --clear
+          makit utility nuget-cache --list
+          makit utility nuget-cache --verify
+      DESC
+
+      option ["--clear"], :flag, "Clear all NuGet caches"
+      option ["--list"], :flag, "List NuGet cache locations"
+      option ["--verify"], :flag, "Verify cache integrity"
+      option ["--cache-type"], "TYPE", "Specific cache to target (global-packages, http-cache, temp, plugins-cache)"
+      option ["--dry-run"], :flag, "Show what would be done without actually doing it"
+      option ["--verbose"], :flag, "Show verbose output"
+
+      def execute
+        unless nuget_available?
+          puts "Error: NuGet CLI is not available. Please install .NET SDK or NuGet CLI tools."
+          exit 1
+        end
+
+        if list?
+          list_cache_locations
+        elsif verify?
+          verify_cache_integrity
+        elsif clear?
+          clear_nuget_caches
+        else
+          show_cache_status
+        end
+      end
+
+      private
+
+      def nuget_available?
+        system("dotnet --version > /dev/null 2>&1") || system("nuget help > /dev/null 2>&1")
+      end
+
+      def show_cache_status
+        puts "NuGet Cache Status:"
+        puts "=" * 50
+
+        cache_locations = get_cache_locations
+        cache_locations.each do |name, path|
+          if Dir.exist?(path)
+            size = calculate_directory_size(path)
+            puts "✅ #{name.ljust(20)} #{path} (#{format_size(size)})"
+          else
+            puts "❌ #{name.ljust(20)} #{path} (not found)"
+          end
+        end
+
+        puts "\nUse --clear to clear all caches, or --list for detailed information."
+      end
+
+      def list_cache_locations
+        puts "NuGet Cache Locations:"
+        puts "=" * 50
+
+        cache_locations = get_cache_locations
+        cache_locations.each do |name, path|
+          puts "\n#{name}:"
+          puts "  Path: #{path}"
+
+          if Dir.exist?(path)
+            size = calculate_directory_size(path)
+            file_count = count_files_in_directory(path)
+            puts "  Status: ✅ Exists"
+            puts "  Size: #{format_size(size)}"
+            puts "  Files: #{file_count}"
+
+            if verbose?
+              recent_files = find_recent_files(path, 5)
+              if recent_files.any?
+                puts "  Recent files:"
+                recent_files.each { |file| puts "    - #{File.basename(file)}" }
+              end
+            end
+          else
+            puts "  Status: ❌ Not found"
+          end
+        end
+      end
+
+      def verify_cache_integrity
+        puts "Verifying NuGet cache integrity..."
+
+        if system("dotnet --version > /dev/null 2>&1")
+          puts "  Running: dotnet nuget verify"
+          success = system("dotnet nuget verify")
+
+          if success
+            puts "✅ Cache verification completed successfully"
+          else
+            puts "❌ Cache verification found issues"
+            puts "Consider clearing the cache with --clear"
+          end
+        else
+          puts "Manual verification of cache locations..."
+          cache_locations = get_cache_locations
+
+          cache_locations.each do |name, path|
+            next unless Dir.exist?(path)
+
+            puts "  Checking #{name}..."
+
+            # Basic checks for common corruption indicators
+            corrupt_files = find_corrupt_files(path)
+            if corrupt_files.any?
+              puts "    ⚠️  Found #{corrupt_files.length} potentially corrupt files"
+              corrupt_files.first(3).each { |file| puts "      - #{file}" }
+              puts "      ... and #{corrupt_files.length - 3} more" if corrupt_files.length > 3
+            else
+              puts "    ✅ No obvious corruption detected"
+            end
+          end
+        end
+      end
+
+      def clear_nuget_caches
+        if dry_run?
+          puts "DRY RUN: Would clear the following NuGet caches:"
+        else
+          puts "Clearing NuGet caches..."
+        end
+
+        if cache_type
+          clear_specific_cache(cache_type)
+        else
+          clear_all_caches
+        end
+
+        if dry_run?
+          puts "✅ Dry run completed - no caches were actually cleared"
+        else
+          puts "✅ NuGet caches cleared successfully"
+        end
+      end
+
+      def clear_specific_cache(type)
+        cache_locations = get_cache_locations
+        path = cache_locations[type]
+
+        if path.nil?
+          puts "Error: Unknown cache type '#{type}'"
+          puts "Valid types: #{cache_locations.keys.join(", ")}"
+          exit 1
+        end
+
+        clear_cache_directory(type, path)
+      end
+
+      def clear_all_caches
+        # Try using dotnet CLI first
+        if system("dotnet --version > /dev/null 2>&1") && !cache_type
+          puts "  Using dotnet nuget locals --clear all" if verbose?
+
+          if dry_run?
+            puts "  Would run: dotnet nuget locals --clear all"
+          else
+            success = system("dotnet nuget locals --clear all")
+            if success
+              puts "  ✅ Cleared all caches using dotnet CLI"
+              return
+            else
+              puts "  ⚠️  dotnet command failed, falling back to manual cleanup"
+            end
+          end
+        end
+
+        # Manual cleanup
+        cache_locations = get_cache_locations
+        cache_locations.each do |name, path|
+          clear_cache_directory(name, path)
+        end
+      end
+
+      def clear_cache_directory(name, path)
+        if Dir.exist?(path)
+          size_before = calculate_directory_size(path)
+
+          if dry_run?
+            puts "  Would clear #{name}: #{path} (#{format_size(size_before)})"
+          else
+            puts "  Clearing #{name}: #{path} (#{format_size(size_before)})" if verbose?
+
+            begin
+              FileUtils.rm_rf(path)
+              FileUtils.mkdir_p(path) # Recreate the directory
+              puts "  ✅ Cleared #{name}" if verbose?
+            rescue StandardError => e
+              puts "  ❌ Failed to clear #{name}: #{e.message}"
+            end
+          end
+        elsif verbose?
+          puts "  #{name} not found: #{path}"
+        end
+      end
+
+      def get_cache_locations
+        # Standard NuGet cache locations
+        home = Dir.home
+
+        locations = {
+          "global-packages" => File.join(home, ".nuget", "packages"),
+          "http-cache" => File.join(home, ".nuget", "v3-cache"),
+          "temp" => File.join(home, ".nuget", "temp"),
+          "plugins-cache" => File.join(home, ".nuget", "plugins-cache"),
+        }
+
+        # Add Windows-specific locations if on Windows
+        if Gem.win_platform?
+          ENV["APPDATA"] || File.join(home, "AppData", "Roaming")
+          local_app_data = ENV["LOCALAPPDATA"] || File.join(home, "AppData", "Local")
+
+          locations["http-cache"] = File.join(local_app_data, "NuGet", "v3-cache")
+          locations["plugins-cache"] = File.join(local_app_data, "NuGet", "plugins-cache")
+        end
+
+        locations
+      end
+
+      def calculate_directory_size(path)
+        return 0 unless Dir.exist?(path)
+
+        total_size = 0
+        Dir.glob(File.join(path, "**", "*")).each do |file|
+          total_size += File.size(file) if File.file?(file)
+        end
+        total_size
+      end
+
+      def count_files_in_directory(path)
+        return 0 unless Dir.exist?(path)
+
+        Dir.glob(File.join(path, "**", "*")).count { |f| File.file?(f) }
+      end
+
+      def format_size(bytes)
+        units = %w[B KB MB GB TB]
+        size = bytes.to_f
+        unit_index = 0
+
+        while size >= 1024 && unit_index < units.length - 1
+          size /= 1024.0
+          unit_index += 1
+        end
+
+        format("%.1f %s", size, units[unit_index])
+      end
+
+      def find_recent_files(path, limit)
+        return [] unless Dir.exist?(path)
+
+        Dir.glob(File.join(path, "**", "*"))
+           .select { |f| File.file?(f) }
+           .sort_by { |f| File.mtime(f) }
+           .reverse
+           .first(limit)
+      end
+
+      def find_corrupt_files(path)
+        return [] unless Dir.exist?(path)
+
+        corrupt_files = []
+
+        Dir.glob(File.join(path, "**", "*")).each do |file|
+          next unless File.file?(file)
+
+          # Check for zero-byte files that shouldn't be empty
+          corrupt_files << file if File.empty?(file) && File.extname(file) =~ /\.(dll|exe|nupkg)$/
+
+          # Check for incomplete downloads (common with network issues)
+          corrupt_files << file if File.basename(file) =~ /\.tmp$/ || File.basename(file) =~ /\.partial$/
+        end
+
+        corrupt_files
+      end
+    end
+
+    # Display system and environment information
+    class SystemInfoCommand < Clamp::Command
+      self.description = <<~DESC
+        Display system information, environment details, and development tool versions.
+
+        Examples:
+          makit utility system-info
+          makit utility system-info --tools-only
+          makit utility system-info --export
+      DESC
+
+      option ["--tools-only"], :flag, "Show only development tool versions"
+      option ["--export"], :flag, "Export information to system-info.txt"
+      option ["--verbose"], :flag, "Show detailed information"
+
+      def execute
+        info = collect_system_info
+
+        if export?
+          export_system_info(info)
+        else
+          display_system_info(info)
+        end
+      end
+
+      private
+
+      def collect_system_info
+        info = {}
+
+        unless tools_only?
+          info[:system] = collect_system_details
+          info[:ruby] = collect_ruby_info
+        end
+
+        info[:tools] = collect_development_tools
+
+        info
+      end
+
+      def collect_system_details
+        {
+          os: RbConfig::CONFIG["host_os"],
+          arch: RbConfig::CONFIG["host_cpu"],
+          user: ENV["USER"] || ENV.fetch("USERNAME", nil),
+          shell: ENV["SHELL"] || "Unknown",
+          pwd: Dir.pwd,
+          home: Dir.home,
+        }
+      end
+
+      def collect_ruby_info
+        {
+          version: RUBY_VERSION,
+          patchlevel: RUBY_PATCHLEVEL,
+          platform: RUBY_PLATFORM,
+          engine: RUBY_ENGINE,
+          gem_version: Gem::VERSION,
+          bundler_version: get_command_version("bundle --version"),
+        }
+      end
+
+      def collect_development_tools
+        tools = {}
+
+        # Version control
+        tools[:git] = get_command_version("git --version")
+
+        # Package managers
+        tools[:npm] = get_command_version("npm --version")
+        tools[:yarn] = get_command_version("yarn --version")
+        tools[:pip] = get_command_version("pip --version")
+
+        # Runtime environments
+        tools[:node] = get_command_version("node --version")
+        tools[:python] = get_command_version("python --version")
+        tools[:python3] = get_command_version("python3 --version")
+
+        # Build tools
+        tools[:make] = get_command_version("make --version")
+        tools[:cmake] = get_command_version("cmake --version")
+
+        # Language-specific tools
+        tools[:dotnet] = get_command_version("dotnet --version")
+        tools[:nuget] = get_command_version("nuget help") # Different format
+        tools[:cargo] = get_command_version("cargo --version")
+        tools[:rustc] = get_command_version("rustc --version")
+        tools[:go] = get_command_version("go version")
+        tools[:java] = get_command_version("java -version")
+        tools[:javac] = get_command_version("javac -version")
+
+        # Editors (just check availability)
+        tools[:code] = command_available?("code --version") ? "Available" : nil
+        tools[:subl] = command_available?("subl --version") ? "Available" : nil
+        tools[:vim] = get_command_version("vim --version")
+        tools[:emacs] = get_command_version("emacs --version")
+
+        # Container tools
+        tools[:docker] = get_command_version("docker --version")
+        tools[:podman] = get_command_version("podman --version")
+
+        tools.compact
+      end
+
+      def get_command_version(command)
+        output = `#{command} 2>&1`.strip
+        return nil if $CHILD_STATUS.exitstatus != 0
+
+        # Extract version number from output
+        version_match = output.match(/(?:v)?(\d+\.[\d.]+(?:-[\w.]+)?)/)
+        version_match ? version_match[1] : output.split("\n").first
+      rescue StandardError
+        nil
+      end
+
+      def command_available?(command)
+        system("#{command} > /dev/null 2>&1")
+      end
+
+      def display_system_info(info)
+        unless tools_only?
+          display_system_section(info[:system])
+          display_ruby_section(info[:ruby])
+        end
+
+        display_tools_section(info[:tools])
+      end
+
+      def display_system_section(system_info)
+        puts "System Information:"
+        puts "=" * 50
+        puts "OS: #{system_info[:os]}"
+        puts "Architecture: #{system_info[:arch]}"
+        puts "User: #{system_info[:user]}"
+        puts "Shell: #{system_info[:shell]}" if system_info[:shell] != "Unknown"
+        puts "Working Directory: #{system_info[:pwd]}"
+        puts "Home Directory: #{system_info[:home]}"
+        puts
+      end
+
+      def display_ruby_section(ruby_info)
+        puts "Ruby Environment:"
+        puts "=" * 50
+        puts "Ruby Version: #{ruby_info[:version]} (patchlevel #{ruby_info[:patchlevel]})"
+        puts "Platform: #{ruby_info[:platform]}"
+        puts "Engine: #{ruby_info[:engine]}"
+        puts "RubyGems Version: #{ruby_info[:gem_version]}"
+        puts "Bundler Version: #{ruby_info[:bundler_version]}" if ruby_info[:bundler_version]
+        puts
+      end
+
+      def display_tools_section(tools_info)
+        puts "Development Tools:"
+        puts "=" * 50
+
+        categories = {
+          "Version Control" => [:git],
+          "Package Managers" => %i[npm yarn pip],
+          "Runtime Environments" => %i[node python python3 dotnet java],
+          "Build Tools" => %i[make cmake cargo rustc go javac],
+          "Editors" => %i[code subl vim emacs],
+          "Container Tools" => %i[docker podman],
+        }
+
+        categories.each do |category, tool_keys|
+          category_tools = tool_keys.map { |key| [key, tools_info[key]] }.select { |_, version| version }
+
+          next if category_tools.empty?
+
+          puts "#{category}:"
+          category_tools.each do |tool, version|
+            puts "  #{tool.to_s.ljust(15)} #{version}"
+          end
+          puts
+        end
+
+        # Show any remaining tools not categorized
+        remaining_tools = tools_info.except(*categories.values.flatten)
+        return unless remaining_tools.any?
+
+        puts "Other Tools:"
+        remaining_tools.each do |tool, version|
+          puts "  #{tool.to_s.ljust(15)} #{version}"
+        end
+      end
+
+      def export_system_info(info)
+        filename = "system-info.txt"
+
+        File.open(filename, "w") do |file|
+          file.puts "System Information Export"
+          file.puts "Generated: #{Time.now.strftime("%Y-%m-%d %H:%M:%S")}"
+          file.puts "=" * 60
+          file.puts
+
+          unless tools_only?
+            file.puts "SYSTEM DETAILS:"
+            info[:system].each { |key, value| file.puts "#{key}: #{value}" }
+            file.puts
+
+            file.puts "RUBY ENVIRONMENT:"
+            info[:ruby].each { |key, value| file.puts "#{key}: #{value}" }
+            file.puts
+          end
+
+          file.puts "DEVELOPMENT TOOLS:"
+          info[:tools].each { |tool, version| file.puts "#{tool}: #{version}" }
+        end
+
+        puts "✅ System information exported to: #{filename}"
+      end
+    end
+
+    # Add subcommand declarations after all classes are defined
+    UtilityCommand.subcommand "nuget-cache", "Manage NuGet package cache", NugetCacheCommand
+    UtilityCommand.subcommand "system-info", "Display system information", SystemInfoCommand
+  end
+end