bruh 0.1.0

data/lib/bruh/cli.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'bruh/version'
+require 'bruh/cabal'
+require 'bruh/hackage'
+require 'bruh/homebrew'
+require 'bruh/bottle'
+require 'bruh/config'
+require 'bruh/changelog'
+
+module Bruh
+  # CLI interface for Bruh commands
+  class CLI < Thor
+    desc 'version', 'Display Bruh version'
+    def version
+      puts "Bruh version #{Bruh::VERSION}"
+    end
+
+    desc 'release', 'Release a new version of a Haskell package to Hackage and Homebrew'
+    option :non_interactive, type: :boolean, desc: 'Run in non-interactive mode (for CI, testing)'
+    option :version, type: :string, desc: 'Version to release (for non-interactive mode)'
+    option :skip_hackage, type: :boolean, desc: 'Skip uploading to Hackage'
+    option :skip_bottles, type: :boolean, desc: 'Skip building Homebrew bottles'
+    option :skip_github, type: :boolean, desc: 'Skip uploading to GitHub'
+    def release
+      interactive = !options[:non_interactive]
+
+      project_root = Dir.pwd
+      cabal_file = find_cabal_file(project_root)
+
+      if cabal_file.nil?
+        puts 'Error: No .cabal file found in current directory or subdirectories'
+        exit 1
+      end
+
+      cabal = Cabal.new(cabal_file)
+
+      current_version = cabal.version
+      puts "Current version: #{current_version}"
+
+      # Determine new version
+      if options[:version] && !options[:version].empty?
+        new_version = options[:version]
+      elsif interactive
+        suggested_version = increment_version(current_version)
+        new_version = prompt('Enter new version', suggested_version)
+      else
+        new_version = increment_version(current_version)
+      end
+
+      puts "Preparing release for version #{new_version}"
+
+      # Update cabal version
+      cabal.update_version(new_version)
+      puts "Updated .cabal file to version #{new_version}"
+
+      # Update changelog
+      if File.exist?('CHANGELOG.md')
+        Changelog.update(new_version, project_root, interactive)
+        puts 'Updated CHANGELOG.md with new version entry'
+      end
+
+      # Run tests
+      puts 'Running tests to verify everything works...'
+      unless system('bundle exec rake test')
+        puts 'Tests failed. Aborting release process.'
+        exit 1 unless yes_no_prompt('Continue anyway?', default_no: false) && interactive
+      end
+
+      # Commit changes if in interactive mode
+      if interactive && yes_no_prompt('Commit version bump and changelog?', default_no: true)
+        system("git add #{cabal_file} CHANGELOG.md")
+        system("git commit -m \"Bump version to #{new_version}\"")
+
+        system('git push origin main') if yes_no_prompt('Push changes to origin?', default_no: true)
+
+        if yes_no_prompt("Create tag v#{new_version}?", default_no: true)
+          if system("git rev-parse v#{new_version} >/dev/null 2>&1")
+            if yes_no_prompt('Tag already exists. Update it?', default_no: true)
+              system("git tag -fa v#{new_version} -m \"Release version #{new_version}\"")
+            end
+          else
+            system("git tag -a v#{new_version} -m \"Release version #{new_version}\"")
+          end
+
+          system("git push origin v#{new_version}") if yes_no_prompt('Push tag to origin?', default_no: true)
+        end
+      end
+
+      # Upload to Hackage
+      unless options[:skip_hackage]
+        puts 'Preparing for Hackage release...'
+        hackage = Hackage.new(interactive)
+
+        if interactive
+          uploaded = hackage.publish(new_version)
+        else
+          # In non-interactive mode, use credentials from config
+          config = Config.load
+          uploaded = hackage.publish_non_interactive(new_version, config[:hackage_username], config[:hackage_password])
+        end
+
+        if uploaded
+          puts 'Successfully published to Hackage!'
+
+          # Calculate package SHA for Homebrew
+          sha256 = hackage.calculate_package_sha256(new_version)
+
+          # Update Homebrew formula
+          if sha256
+            puts 'Updating Homebrew formula...'
+            formula = Homebrew.new(interactive)
+            formula.update(new_version, sha256)
+
+            # Build bottle if requested
+            unless options[:skip_bottles]
+              puts 'Building Homebrew bottle...'
+              bottle = Bottle.new(interactive)
+              bottle_info = bottle.build(new_version)
+
+              if bottle_info && !options[:skip_github]
+                puts 'Uploading bottle to GitHub...'
+                bottle.upload_to_github(new_version, bottle_info)
+
+                puts 'Updating formula with bottle information...'
+                formula.update_bottle_info(bottle_info)
+              end
+            end
+          end
+        end
+      end
+
+      puts 'Release process complete!'
+    end
+
+    desc 'config_setup', 'Set up configuration'
+    def config_setup
+      Config.setup_credentials(true)
+      puts 'Configuration setup complete.'
+    end
+
+    desc 'config_get', 'Get a configuration value'
+    def config_get(key)
+      value = Config.get(key.to_sym)
+      puts "#{key}: #{value}"
+    end
+
+    desc 'config_set', 'Set a configuration value'
+    def config_set(key, value)
+      Config.set(key.to_sym, value)
+      puts "Set #{key} = #{value}"
+    end
+
+    private
+
+    def find_cabal_file(dir)
+      Dir.glob("#{dir}/**/*.cabal").first
+    end
+
+    def increment_version(version)
+      if version =~ /(\d+)\.(\d+)\.(\d+)/
+        major = ::Regexp.last_match(1).to_i
+        minor = ::Regexp.last_match(2).to_i
+        patch = ::Regexp.last_match(3).to_i
+        "#{major}.#{minor}.#{patch + 1}"
+      else
+        "#{version}.1"
+      end
+    end
+
+    def prompt(message, default = nil)
+      if default
+        print "#{message} [#{default}]: "
+      else
+        print "#{message}: "
+      end
+      input = $stdin.gets.chomp.strip
+      input.empty? ? default : input
+    end
+
+    def yes_no_prompt(message, default_no: true)
+      default = default_no ? '[y/N]' : '[Y/n]'
+      print "#{message} #{default} "
+      response = $stdin.gets.chomp.downcase
+      return response.start_with?('y') if default_no
+
+      !response.start_with?('n')
+    end
+  end
+end

data/lib/bruh/config.rb

@@ -0,0 +1,134 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'toml-rb'
+require 'sorbet-runtime'
+
+module Bruh
+  # Manages configuration for Bruh
+  class Config
+    extend T::Sig
+
+    CONFIG_DIR = T.let(File.expand_path('~/.config/bruh').freeze, String)
+    CONFIG_FILE = T.let(File.join(CONFIG_DIR, 'config.toml').freeze, String)
+
+    sig { returns(T::Hash[Symbol, T.untyped]) }
+    def self.load
+      ensure_config_exists
+
+      begin
+        config = TomlRB.load_file(CONFIG_FILE)
+        symbolize_keys(config)
+      rescue StandardError => e
+        puts "Error loading config: #{e.message}"
+        {}
+      end
+    end
+
+    sig { params(config: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
+    def self.save(config)
+      ensure_config_exists
+
+      begin
+        File.write(CONFIG_FILE, TomlRB.dump(stringify_keys(config)))
+        true
+      rescue StandardError => e
+        puts "Error saving config: #{e.message}"
+        false
+      end
+    end
+
+    sig { params(key: Symbol, value: T.untyped).returns(T::Boolean) }
+    def self.set(key, value)
+      config = load
+      config[key] = value
+      save(config)
+    end
+
+    sig { params(key: Symbol).returns(T.untyped) }
+    def self.get(key)
+      config = load
+      config[key]
+    end
+
+    sig { params(interactive: T::Boolean).returns(T::Hash[Symbol, T.untyped]) }
+    def self.setup_credentials(interactive: true)
+      config = load
+
+      if interactive
+        # Prompt for credentials
+        puts 'Setting up Hackage credentials:'
+        print 'Hackage username: '
+        username = gets.chomp
+
+        print 'Hackage password (input will be hidden): '
+        system('stty -echo')
+        password = gets.chomp
+        system('stty echo')
+        puts
+
+        puts 'Setting up GitHub credentials:'
+        print 'GitHub token (for bottle uploads): '
+        system('stty -echo')
+        github_token = gets.chomp
+        system('stty echo')
+        puts
+
+        # Save credentials
+        config[:hackage_username] = username
+        config[:hackage_password] = password
+        config[:github_token] = github_token
+
+        save(config)
+      end
+
+      config
+    end
+
+    sig { returns(NilClass) }
+    def self.ensure_config_exists
+      FileUtils.mkdir_p(CONFIG_DIR) unless Dir.exist?(CONFIG_DIR)
+
+      unless File.exist?(CONFIG_FILE)
+        default_config = {
+          hackage_username: '',
+          hackage_password: '',
+          github_token: '',
+          default_formula_template: 'standard',
+          bottle_platforms: ['arm64_monterey']
+        }
+
+        File.write(CONFIG_FILE, TomlRB.dump(default_config))
+      end
+
+      nil
+    end
+
+    sig { params(hash: T::Hash[T.untyped, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+    def self.symbolize_keys(hash)
+      result = {}
+      hash.each do |key, value|
+        result[key.to_sym] = if value.is_a?(Hash)
+                               symbolize_keys(value)
+                             else
+                               value
+                             end
+      end
+      result
+    end
+
+    sig { params(hash: T::Hash[Symbol, T.untyped]).returns(T::Hash[String, T.untyped]) }
+    def self.stringify_keys(hash)
+      result = {}
+      hash.each do |key, value|
+        result[key.to_s] = if value.is_a?(Hash)
+                             stringify_keys(value)
+                           else
+                             value
+                           end
+      end
+      result
+    end
+  end
+end

data/lib/bruh/hackage.rb

@@ -0,0 +1,159 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'net/http'
+require 'digest'
+require 'sorbet-runtime'
+
+module Bruh
+  # Handles interaction with Hackage package manager
+  class Hackage
+    extend T::Sig
+
+    sig { params(interactive: T::Boolean).void }
+    def initialize(interactive: true)
+      @interactive = interactive
+    end
+
+    sig { params(version: String).returns(T::Boolean) }
+    def publish(version)
+      puts '=== Ready to upload to Hackage ==='
+
+      package_path = build_package(version)
+      return false unless package_path
+
+      if @interactive
+        puts 'The following command will upload the package to Hackage:'
+        puts "  cabal upload --publish #{package_path}"
+
+        if yes_no_prompt('Do you want to upload to Hackage now?')
+          publish_package(package_path)
+        else
+          puts 'Skipping Hackage upload. Run the command manually when ready.'
+          false
+        end
+      else
+        # In non-interactive mode, just publish
+        publish_package(package_path)
+      end
+    end
+
+    sig { params(version: String, username: String, password: String).returns(T::Boolean) }
+    def publish_non_interactive(version, username, password)
+      package_path = build_package(version)
+      return false unless package_path
+
+      # Use HTTP Basic auth with credentials
+      cmd = "curl -X PUT --data-binary \"@#{package_path}\" " \
+            "-H 'Content-Type: application/x-tar' " \
+            "-H 'Content-Encoding: gzip' " \
+            "--user \"#{username}:#{password}\" " \
+            '"https://hackage.haskell.org/packages/upload"'
+
+      T.must(system(cmd))
+    end
+
+    sig { params(version: String).returns(T.nilable(String)) }
+    def calculate_package_sha256(version)
+      puts '=== Calculating SHA256 for Hackage package ==='
+
+      # Wait for package to be available
+      puts 'Waiting for Hackage to process the package (10 seconds)...'
+      sleep 10 if @interactive
+
+      package_name = File.basename(Dir.pwd)
+      hackage_url = "https://hackage.haskell.org/package/#{package_name}-#{version}/#{package_name}-#{version}.tar.gz"
+
+      max_attempts = 3
+      attempt = 1
+      sha256 = T.let(nil, T.nilable(String))
+
+      while attempt <= max_attempts && sha256.nil?
+        puts "Attempt #{attempt} of #{max_attempts} to calculate SHA256..."
+
+        begin
+          uri = URI(hackage_url)
+          response = Net::HTTP.get_response(uri)
+
+          if response.is_a?(Net::HTTPSuccess) && !response.body.empty?
+            sha256 = Digest::SHA256.hexdigest(response.body)
+
+            # Validate SHA256 format (64 hex chars)
+            if sha256 =~ /^[0-9a-f]{64}$/
+              puts "Valid SHA256 obtained: #{sha256}"
+              break
+            else
+              puts 'Invalid SHA256 obtained. Retrying...'
+              sha256 = T.let(nil, T.nilable(String))
+            end
+          else
+            puts 'Package not available yet or empty response.'
+          end
+        rescue StandardError => e
+          puts "Error downloading package: #{e.message}"
+        end
+
+        # Wait before retrying
+        wait_time = attempt * 5
+        puts "Waiting #{wait_time} seconds before retry..."
+        sleep wait_time
+        attempt += 1
+      end
+
+      if sha256.nil?
+        puts "Error: Failed to calculate SHA256 after #{max_attempts} attempts."
+        puts 'The package might not be available on Hackage yet.'
+        nil
+      else
+        sha256
+      end
+    end
+
+    private
+
+    sig { params(version: String).returns(T.nilable(String)) }
+    def build_package(version)
+      # Run necessary steps to build the package
+      puts 'Building documentation for Hackage...'
+      unless system('cabal haddock --haddock-for-hackage')
+        puts 'Failed to build documentation'
+        return nil
+      end
+
+      puts 'Creating source distribution...'
+      unless system('cabal sdist')
+        puts 'Failed to create source distribution'
+        return nil
+      end
+
+      # Find the generated package file
+      package_name = File.basename(Dir.pwd)
+      package_path = "dist-newstyle/sdist/#{package_name}-#{version}.tar.gz"
+
+      unless File.exist?(package_path)
+        puts "Generated package not found at #{package_path}"
+        return nil
+      end
+
+      package_path
+    end
+
+    sig { params(package_path: String).returns(T::Boolean) }
+    def publish_package(package_path)
+      puts 'Uploading package to Hackage...'
+      T.must(system("cabal upload --publish \"#{package_path}\""))
+    end
+
+    sig { params(message: String, default_no: T::Boolean).returns(T::Boolean) }
+    def yes_no_prompt(message, default_no: true)
+      return true unless @interactive
+
+      default = default_no ? '[y/N]' : '[Y/n]'
+      print "#{message} #{default} "
+      response = gets.chomp.downcase
+      return response.start_with?('y') if default_no
+
+      !response.start_with?('n')
+    end
+  end
+end

data/lib/bruh/homebrew.rb

@@ -0,0 +1,223 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+module Bruh
+  # Manages Homebrew formula creation and updates
+  class Homebrew
+    extend T::Sig
+
+    sig { params(interactive: T::Boolean).void }
+    def initialize(interactive: true)
+      @interactive = interactive
+      @tap_dir = T.let(find_homebrew_tap, T.nilable(String))
+      @formula_path = T.let(find_formula_path, T.nilable(String))
+    end
+
+    sig { params(version: String, sha256: String).returns(T::Boolean) }
+    def update(version, sha256)
+      unless @formula_path && File.exist?(@formula_path)
+        puts "Error: Formula file not found at #{@formula_path}"
+        return false
+      end
+
+      puts "Updating Homebrew formula with new version #{version} and SHA256 #{sha256}..."
+
+      # Read current formula
+      formula_content = File.read(@formula_path)
+
+      # Verify markers exist
+      unless formula_content.include?('url') && formula_content.include?('sha256')
+        puts 'ERROR: Required fields not found in formula. Cannot update safely.'
+        return false
+      end
+
+      # Update version in URL
+      formula_content.gsub!(/url\s+"[^"]+"/, "url \"https://hackage.haskell.org/package/#{package_name}-#{version}/#{package_name}-#{version}.tar.gz\"")
+
+      # Update SHA256
+      formula_content.gsub!(/sha256\s+"[a-f0-9]+"/, "sha256 \"#{sha256}\"")
+
+      # Write updated formula
+      File.write(@formula_path, formula_content)
+
+      # Verify the update was successful
+      updated_content = File.read(@formula_path)
+      if !updated_content.include?("#{package_name}-#{version}.tar.gz") ||
+         !updated_content.include?("sha256 \"#{sha256}\"")
+        puts 'ERROR: Formula update verification failed.'
+        return false
+      end
+
+      puts 'Formula updated successfully with new version and SHA256.'
+
+      # Commit the changes if interactive
+      if @interactive && yes_no_prompt('Commit formula changes?')
+        Dir.chdir(File.dirname(@formula_path)) do
+          system("git add #{File.basename(@formula_path)}")
+          system("git commit -m \"Update formula to version #{version}\"")
+
+          system('git push origin main') if yes_no_prompt('Push formula changes to origin?', default_no: true)
+        end
+      end
+
+      true
+    end
+
+    sig { params(bottle_info: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
+    def update_bottle_info(bottle_info)
+      unless @formula_path && File.exist?(@formula_path)
+        puts 'Error: Formula file not found'
+        return false
+      end
+
+      macos_version = bottle_info[:macos_version]
+      bottle_sha = bottle_info[:sha256]
+      rebuild_num = bottle_info[:rebuild] || 0
+
+      formula_content = File.read(@formula_path)
+
+      # Check if bottle block exists
+      if formula_content.include?('bottle do')
+        # Update existing bottle block
+
+        # Update rebuild directive if needed
+        if rebuild_num.positive?
+          if formula_content =~ /\s+rebuild\s+\d+/
+            formula_content.gsub!(/(\s+rebuild\s+)\d+/, "\\1#{rebuild_num}")
+          else
+            formula_content.gsub!(/(\s+root_url.*)$/, "\\1\n    rebuild #{rebuild_num}")
+          end
+        else
+          # Remove rebuild directive if it exists
+          formula_content.gsub!(/\s+rebuild\s+\d+\n/, "\n")
+        end
+
+        # Update SHA256 for the specific platform
+        if formula_content =~ /sha256\s+cellar:[^,]+,\s+arm64_[^:]+:/
+          formula_content.gsub!(/sha256\s+cellar:[^,]+,\s+arm64_[^:]+:\s+"[a-f0-9]+"/,
+                                "sha256 cellar: :any, arm64_#{macos_version}: \"#{bottle_sha}\"")
+        else
+          # Add line for this platform
+          formula_content.gsub!(/(\s+root_url\s+"[^"]+".*$)/,
+                                "\\1\n    sha256 cellar: :any, arm64_#{macos_version}: \"#{bottle_sha}\"")
+        end
+      else
+        # Create bottle block after sha256 line
+        bottle_block = <<~BOTTLE
+
+          bottle do
+            root_url "https://github.com/#{repo_owner}/#{repo_name}/releases/download/v#{bottle_info[:version]}"
+            sha256 cellar: :any, arm64_#{macos_version}: "#{bottle_sha}"
+          end
+        BOTTLE
+
+        formula_content.gsub!(/sha256\s+"[a-f0-9]+"/, "\\0#{bottle_block}")
+      end
+
+      # Write updated formula
+      File.write(@formula_path, formula_content)
+
+      # Verify the update was successful
+      updated_content = File.read(@formula_path)
+      unless updated_content.include?("arm64_#{macos_version}: \"#{bottle_sha}\"")
+        puts 'ERROR: Bottle SHA update failed.'
+        return false
+      end
+
+      puts 'Bottle information updated successfully.'
+
+      # Commit the changes if interactive
+      if @interactive && yes_no_prompt('Commit bottle changes?')
+        Dir.chdir(File.dirname(@formula_path)) do
+          system("git add #{File.basename(@formula_path)}")
+          system("git commit -m \"Add bottle for version #{bottle_info[:version]}\"")
+
+          system('git push origin main') if yes_no_prompt('Push bottle changes to origin?', default_no: true)
+        end
+      end
+
+      true
+    end
+
+    private
+
+    sig { returns(T.nilable(String)) }
+    def find_homebrew_tap
+      # Try common locations
+      potential_paths = [
+        '../homebrew-tap',
+        '~/homebrew-tap',
+        '~/Projects/homebrew-tap'
+      ]
+
+      potential_paths.each do |path|
+        expanded = File.expand_path(path)
+        return expanded if Dir.exist?(expanded)
+      end
+
+      if @interactive
+        puts 'Homebrew tap directory not found in common locations.'
+        tap_dir = gets.chomp.strip
+        return tap_dir if !tap_dir.empty? && Dir.exist?(tap_dir)
+      end
+
+      nil
+    end
+
+    sig { returns(T.nilable(String)) }
+    def find_formula_path
+      return nil unless @tap_dir
+
+      # Try to find the formula file
+      formula_name = package_name
+      formula_path = File.join(@tap_dir, 'Formula', "#{formula_name}.rb")
+
+      return formula_path if File.exist?(formula_path)
+
+      # If not found in standard location, try to find elsewhere
+      Dir.glob(File.join(@tap_dir, '**', "#{formula_name}.rb")).first
+    end
+
+    sig { returns(String) }
+    def package_name
+      # Extract package name from current directory
+      File.basename(Dir.pwd)
+    end
+
+    sig { returns(T::Array[String]) }
+    def repo_info
+      # Extract owner and repo from git remote
+      remote = `git remote get-url origin`.chomp
+      if remote =~ %r{github\.com[:/]([^/]+)/([^/]+)\.git}
+        owner = T.let(T.must(::Regexp.last_match(1)), String)
+        repo = T.let(T.must(::Regexp.last_match(2)), String)
+        return [owner, repo]
+      end
+
+      %w[user repo]
+    end
+    sig { returns(String) }
+    def repo_owner
+      T.must(repo_info[0])
+    end
+
+    sig { returns(String) }
+    def repo_name
+      T.must(repo_info[1])
+    end
+
+    sig { params(message: String, default_no: T::Boolean).returns(T::Boolean) }
+    def yes_no_prompt(message, default_no: true)
+      return true unless @interactive
+
+      default = default_no ? '[y/N]' : '[Y/n]'
+      print "#{message} #{default} "
+      response = gets.chomp.downcase
+      return response.start_with?('y') if default_no
+
+      !response.start_with?('n')
+    end
+  end
+end