githuh 0.2.1 → 0.4.0

data/lefthook.yml

@@ -0,0 +1,35 @@
+output:
+  - summary
+  - failure
+
+pre-commit:
+  parallel: true
+  jobs:
+    - name: lint
+      run: bundle exec rubocop -c .rubocop.yml {staged_files}
+      glob: "*.{rb,Gemfile}"
+      stage_fixed: true
+
+    - name: check for conflict markers and whitespace issues
+      run: git --no-pager diff --check
+
+    # If tests take >1 second, move this (or just the long-running tests) to pre-push.
+    - name: run tests
+      run: just test
+
+    - name: fix rubocop formatting issues
+      run: bundle exec rubocop -a {staged_files}
+      glob: "*.{rb,Gemfile,gemspec}"
+      stage_fixed: true
+
+    - name: spell check
+      run: codespell {staged_files}
+      glob: "*.{rb,md,gemspec}"
+
+    - name: format markdown
+      run: mdformat {staged_files}
+      glob: "*.md"
+      stage_fixed: true
+
+    - name: scan for secrets
+      run: detect-secrets-hook --baseline .secrets.baseline

data/lib/githuh/cli/commands/base.rb

@@ -28,31 +28,39 @@ module Githuh
           end
         end
 
-        attr_accessor :client, :token, :per_page, :verbose, :info, :box, :context
+        attr_accessor :token, :per_page, :verbose, :info, :box, :context
 
         def call(api_token: nil,
                  per_page: DEFAULT_PAGE_SIZE,
                  verbose: false,
                  info: true)
-
           self.context  = Githuh
           self.verbose  = verbose
           self.info     = info
-          self.token    = api_token || token_from_gitconfig
-          self.per_page = per_page.to_i || DEFAULT_PAGE_SIZE
-          self.client   = Octokit::Client.new(access_token: token)
+          self.token    = api_token || determine_github_token
+          self.per_page = per_page.to_i
+
+          return unless info
+
+          begin
+            print_userinfo
+          rescue StandardError
+            nil
+          end
+        end
 
-          print_userinfo if info
+        def client
+          @client ||= Octokit::Client.new(access_token: token)
         end
 
         protected
 
-        def puts(*args)
-          stdout.puts(*args)
+        def puts(*)
+          stdout.puts(*)
         end
 
-        def warn(*args)
-          stderr.puts(*args)
+        def warn(*)
+          stderr.puts(*)
         end
 
         def user_info
@@ -83,20 +91,34 @@ module Githuh
                                complete: '▉'.magenta)
         end
 
+        def determine_github_token
+          @github_token ||= ENV['GITHUB_TOKEN'] || `git config --global --get user.token`.chomp
+
+          return @github_token unless @github_token.empty?
+
+          raise "No token was found in your ~/.gitconfig.\n" \
+                "To add, run the following command: \n" \
+                "git config --global --set user.token YOUR_GITHUB_TOKEN\n" \
+                "or set environment variable GITHUB_TOKEN"
+        end
+
         private
 
         def print_userinfo
           duration = DateTime.now - DateTime.parse(user_info[:created_at].to_s)
           years    = (duration / 365).to_i
-          months   = ((duration - years * 365) / 30).to_i
-          days     = (duration - years * 365 - months * 30).to_i
+          months   = ((duration - (years * 365)) / 30).to_i
+          days     = (duration - (years * 365) - (months * 30)).to_i
 
           lines = []
-          lines << sprintf("  Github API Token: %s", h("#{token[0..9]}#{'.' * 20}#{token[-11..-1]}"))
+          lines << sprintf("  Github API Token: %s", h("#{token[0..9]}#{'.' * 20}#{token[-11..]}"))
           lines << sprintf("      Current User: %s", h(user_info.login))
           lines << sprintf("      Public Repos: %s", h(user_info.public_repos.to_s))
           lines << sprintf("         Followers: %s", h(user_info.followers.to_s))
-          lines << sprintf("        Member For: %s", h(sprintf("%d years, %d months, %d days", years, months, days)))
+          lines << sprintf(
+            "        Member For: %s",
+            h("%<years>d years, %<months>d months, %<days>d days" % { years:, months:, days: })
+          )
 
           self.box = TTY::Box.frame(*lines,
                                     padding: 0,
@@ -116,16 +138,6 @@ module Githuh
         def h(arg)
           arg.to_s
         end
-
-        def token_from_gitconfig
-          @token_from_gitconfig ||= `git config --global --get user.token`.chomp
-
-          return @token_from_gitconfig unless @token_from_gitconfig.empty?
-
-          raise "No token was found in your ~/.gitconfig.\n" \
-                "To add, run the following command: \n" \
-                "git config --global --set user.token YOUR_GITHUB_TOKEN"
-        end
       end
     end
   end

data/lib/githuh/cli/commands/issue/export.rb

@@ -2,14 +2,15 @@
 # frozen_string_literal: true
 
 # vim: ft=ruby
-require 'bundler/setup'
-require 'dry/cli'
-require 'json'
-require 'tty/progressbar'
-require 'csv'
-require 'active_support/inflector'
+require "bundler/setup"
+require "dry/cli"
+require "json"
+require "tty/progressbar"
+require "active_support/inflector"
+require "yaml"
+require "csv"
 
-require_relative '../base'
+require_relative "../base"
 
 module Githuh
   module CLI
@@ -17,40 +18,51 @@ module Githuh
       module Issue
         class Export < Base
           FORMATS = {
-            json: 'json',
-            csv:  'csv'
+            json: "json",
+            csv:  "csv",
           }.freeze
 
-          DEFAULT_FORMAT        = :csv
+          DEFAULT_FORMAT = :csv
           DEFAULT_OUTPUT_FORMAT = "<username>.<repo>.issues.<format>"
 
-          attr_accessor :filename, :file, :output, :repo, :issues, :format, :record_count
+          attr_accessor :filename, :file, :output, :repo, :issues, :format, :record_count, :mapping
 
-          desc "Export Repo issues into a CSV or JSON format\n" \
-               "  Default output file is " + DEFAULT_OUTPUT_FORMAT.bold.yellow
+          desc "Export Repo issues into a CSV or JSON format\n  " \
+               "Default output file is " + DEFAULT_OUTPUT_FORMAT.bold.yellow
 
           argument :repo, type: :string, required: true, desc: 'Name of the repo, eg "rails/rails"'
-          option :file, required: false, desc: 'Output file, overrides ' + DEFAULT_OUTPUT_FORMAT
-          option :format, values: FORMATS.keys.map(&:to_s), default: DEFAULT_FORMAT.to_s, required: false, desc: 'Output format'
+          option :file, required: false, desc: "Output file, overrides #{DEFAULT_OUTPUT_FORMAT}"
+          option :format, values: FORMATS.keys.map(&:to_s), default: DEFAULT_FORMAT.to_s, required: false, desc: "Output format"
+          option :mapping, type: :string, require: false, desc: "YAML file with label to estimates mapping"
 
-          def call(repo: nil, file: nil, format: nil, **opts)
-            super(**opts)
+          def call(repo: nil, file: nil, format: nil, mapping: nil, **)
+            super(**)
 
             self.record_count = 0
-            self.repo         = repo
+            self.repo = repo
 
             raise ArgumentError, "argument <repo> is required" unless repo
             raise ArgumentError, "argument <repo> is not a repository, expected eg 'rails/rails'" unless repo =~ %r{/}
 
+            self.mapping = {}
+            if mapping && ::File.exist?(mapping)
+              self.mapping = ::YAML.safe_load_file(mapping)['label-to-estimates'] || {}
+            end
+
+            Export.send(:remove_const, :LabelEstimates) if Export.const_defined?(:LabelEstimates)
+            Export.const_set(:LabelEstimates, self.mapping)
+
             self.issues = []
             self.output = StringIO.new
             self.format = (format || DEFAULT_FORMAT).to_sym
 
             self.filename = file || file_name(repo)
-            self.file     = File.open(filename, 'w')
+            self.file = File.open(filename, "w")
 
             print_summary
 
+            raise ArgumentError, "Format is not provided" unless FORMATS.key?(format&.to_sym)
+
             # —————————— actually get all issues ———————————————
             self.file.write send("render_as_#{format}", fetch_issues)
             # ————————————————————————————————————————————————————————
@@ -62,9 +74,9 @@ module Githuh
 
           def fetch_issues
             client.auto_paginate = true
-            self.issues          = filter_issues(client.issues(repo, query: default_options)).tap do |issue_list|
+            self.issues = filter_issues(client.issues(repo, query: default_options)).tap do |issue_list|
               self.record_count = issue_list.size
-              bar('Issues')&.advance
+              bar("Issues")&.advance
             end
           end
 
@@ -79,7 +91,7 @@ module Githuh
           end
 
           def default_options
-            { state: 'open' }
+            { state: "open" }
           end
 
           def self.issue_labels(issue)
@@ -87,42 +99,33 @@ module Githuh
           end
 
           def self.find_user(client, username)
-            @user_cache           ||= {}
+            @user_cache ||= {}
             @user_cache[username] ||= client.user(username).name
           end
 
           CSV_MAP = {
-            'Labels'        => ->(_client, issue) { issue_labels(issue).reject { |l| LABEL_ESTIMATES.key?(l) }.join(',').downcase },
-            'Type'          => ->(*) { 'feature' },
-            'Estimate'      => ->(_client, issue) do
-              el = issue_labels(issue).find { |l| LABEL_ESTIMATES.key?(l) }
-              el ? LABEL_ESTIMATES[el] : nil
+            "Labels" => ->(_client, issue) { issue_labels(issue).reject { |l| LabelEstimates.key?(l) }.join(",").downcase },
+            "Type" => ->(*) { "feature" },
+            "Estimate" => ->(_client, issue) do
+              el = issue_labels(issue).find { |l| LabelEstimates.key?(l) }
+              el ? LabelEstimates[el] : nil
             end,
-            'Current State' => ->(*) { 'unstarted' },
-            'Requested By'  => ->(client, issue) do
+            "Current State" => ->(*) { "unstarted" },
+            "Requested By" => ->(client, issue) do
               find_user(client, issue.user.login)
             end,
-            'Owned By'  => ->(client, issue) do
+            "Owned By" => ->(client, issue) do
               find_user(client, issue.user.login)
             end,
-            'Description'   => ->(_client, issue) {
+            "Description" => ->(_client, issue) {
               issue.body
             },
-            'Created at'    => ->(_client, issue) { issue.created_at },
-          }.freeze
-
-          LABEL_ESTIMATES = {
-            'XXL(13 eng day)' => 15,
-            'XL(8 eng day)'   => 15,
-            'xs(<=1 eng day)' => 3,
-            'L(5 eng day)'    => 15,
-            'm(3 eng day)'    => 9,
-            's(2 eng day)'    => 6
+            "Created at" => ->(_client, issue) { issue.created_at },
           }.freeze
 
           CSV_HEADER = %w(Id Title Labels Type Estimate) +
-            ['Current State', 'Created at', 'Accepted at', 'Deadline', 'Requested By',
-             'Owned By', 'Description', 'Comment', 'Comment', 'Comment', 'Comment'].freeze
+                       ["Current State", "Created at", "Accepted at", "Deadline", "Requested By",
+                        "Owned By", "Description", "Comment", "Comment", "Comment", "Comment"].freeze
 
           # Id,Title,Labels,Type,Estimate,Current State,Created at,Accepted at,Deadline,Requested By,Owned By,Description,Comment,Comment
           # 100, existing started story,"label one,label two",feature,1,started,"Nov 22, 2007",,,user1,user2,this will update story 100,,
@@ -136,16 +139,16 @@ module Githuh
                 row = []
                 CSV_HEADER.each do |column|
                   method = column.downcase.underscore.to_sym
-                  value  = if CSV_MAP[column]
-                    CSV_MAP[column][client, issue]
-                  else
-                    begin
-                      issue.to_h[method]
-                    rescue StandardError
-                      nil
-                    end
-                  end
-                  value  = value.strip if value.is_a?(String)
+                  value = if CSV_MAP[column]
+                            CSV_MAP[column][client, issue]
+                          else
+                            begin
+                              issue.to_h[method]
+                            rescue StandardError
+                              nil
+                            end
+                          end
+                  value = value.strip if value.is_a?(String)
                   row << value
                 end
                 csv << row
@@ -173,8 +176,7 @@ module Githuh
             puts TTY::Box.info("Format : #{self.format}\n" \
                                "File   : #{filename}\n" \
                                "Repo   : #{repo}\n",
-                               width:   ui_width,
-                               padding: 1)
+                               width: ui_width, padding: 1)
             puts
           end
 
@@ -184,8 +186,8 @@ module Githuh
         end
       end
 
-      register 'issue', aliases: ['r'] do |prefix|
-        prefix.register 'export', Issue::Export
+      register "issue", aliases: ["r"] do |prefix|
+        prefix.register "export", Issue::Export
       end
     end
   end

data/lib/githuh/cli/commands/repo/list.rb

@@ -4,10 +4,12 @@
 # vim: ft=ruby
 require 'bundler/setup'
 require 'dry/cli'
+require 'base64'
 require 'json'
 require 'tty/progressbar'
 
 require_relative '../base'
+require_relative '../../../llm'
 
 module Githuh
   module CLI
@@ -23,18 +25,42 @@ module Githuh
           DEFAULT_OUTPUT_FORMAT = "<username>.repositories.<format>"
           FORK_OPTIONS          = %w(exclude include only).freeze
 
-          attr_accessor :filename, :file, :output, :repos, :format, :forks, :private, :record_count
+          attr_accessor :filename, :file, :output, :repos, :format,
+                        :forks, :private, :record_count, :llm_adapter
 
-          desc "List owned repositories and render the output in markdown or JSON\n" \
-               "  Default output file is " + DEFAULT_OUTPUT_FORMAT.bold.yellow
+          desc "List owned repositories and render the output in markdown or JSON\n  " \
+               "Default output file is " + DEFAULT_OUTPUT_FORMAT.bold.yellow
 
-          option :file, required: false, desc: 'Output file, overrides ' + DEFAULT_OUTPUT_FORMAT
-          option :format, values: FORMATS.keys, default: DEFAULT_FORMAT.to_s, required: false, desc: 'Output format'
-          option :forks, type: :string, values: FORK_OPTIONS, default: FORK_OPTIONS.first, required: false, desc: 'Include or exclude forks'
-          option :private, type: :boolean, default: nil, required: false, desc: 'If specified, returns only private repos for true, public for false'
+          option :file,
+                 required: false,
+                 desc:     "Output file, overrides #{DEFAULT_OUTPUT_FORMAT}"
 
-          def call(file: nil, format: nil, forks: nil, private: nil, **opts)
-            super(**opts)
+          option :format,
+                 values:   FORMATS.keys,
+                 default:  DEFAULT_FORMAT.to_s,
+                 required: false,
+                 desc:     'Output format'
+
+          option :forks, type:     :string,
+                         values:   FORK_OPTIONS,
+                         default:  FORK_OPTIONS.first,
+                         required: false,
+                         desc:     'Include or exclude forks'
+
+          option :private,
+                 type:     :boolean,
+                 default:  nil,
+                 required: false,
+                 desc:     'If specified, returns only private repos for true, public for false'
+
+          option :llm,
+                 type:     :boolean,
+                 default:  false,
+                 required: false,
+                 desc:     'Use LLM (ANTHROPIC_API_KEY or OPENAI_API_KEY) to summarize README'
+
+          def call(file: nil, format: nil, forks: nil, private: nil, llm: false, **)
+            super(**)
 
             self.record_count = 0
             self.forks        = forks
@@ -42,6 +68,7 @@ module Githuh
             self.repos        = []
             self.output       = StringIO.new
             self.format       = (format || DEFAULT_FORMAT).to_sym
+            self.llm_adapter  = build_llm_adapter if llm
 
             self.filename = file || "#{user_info.login}.repositories.#{FORMATS[self.format]}"
             self.file     = File.open(filename, 'w')
@@ -98,55 +125,139 @@ module Githuh
           end
 
           def bar_size
-            client.last_response.rels[:last].href.match(/page=(\d+).*$/)[1].to_i
+            return 1 if client&.last_response.nil?
+
+            client&.last_response&.rels&.[](:last)&.href&.match(/page=(\d+).*$/)&.[](1)&.to_i # rubocop:disable Style/SafeNavigationChainLength
           end
 
           def render_as_markdown(repositories)
             output.puts "### #{client.user.name}'s Repos\n"
+
+            llm_bar = build_llm_progress_bar(repositories.size) if llm_adapter
+
             repositories.each_with_index do |repo, index|
               output.puts repo_as_markdown(index, repo)
+              llm_bar&.advance
+            end
+
+            if llm_bar
+              llm_bar.finish
+              puts
             end
+
             output.string
           end
 
+          def build_llm_progress_bar(total)
+            return unless info || verbose
+
+            color = llm_adapter.class.const_defined?(:BAR_COLOR) ? llm_adapter.class::BAR_COLOR : :cyan
+            provider = llm_adapter.class.name.split('::').last
+
+            puts
+            puts " • Summarizing #{total} READMEs with #{provider}…".send(color)
+            TTY::ProgressBar.new("[:bar]",
+                                 title:    'LLM Summaries',
+                                 total:    total,
+                                 width:    ui_width - 2,
+                                 head:     '',
+                                 complete: '▉'.send(color))
+          end
+
           def render_as_json(repositories)
             JSON.pretty_generate(repositories.map(&:to_hash))
           end
 
           def repo_as_markdown(index, repo)
+            description = describe(repo)
+
             <<~REPO
 
               ### #{index + 1}. [#{repo.name}](#{repo.url}) (#{repo.stargazers_count} ★)
 
-              #{repo.language ? "**#{repo.language}**. " : ''}
-              #{repo.license ? "Distributed under the **#{repo.license.name}** license." : ''}
+              #{"**#{repo.language}**. " if repo.language}
+              #{"Distributed under the **#{repo.license.name}** license." if repo.license}
 
-              #{repo.description}
+              #{description}
 
             REPO
           end
 
+          def describe(repo)
+            return repo.description unless llm_adapter
+
+            readme = fetch_readme(repo)
+            return repo.description if readme.nil? || readme.empty?
+
+            llm_adapter.summarize(readme)
+          rescue StandardError => e
+            warn "LLM summary failed for #{repo_full_name(repo)}: #{e.message}" if verbose
+            repo.description
+          end
+
+          def fetch_readme(repo)
+            readme = client.readme(repo_full_name(repo))
+            return nil unless readme
+
+            encoded = readme.respond_to?(:content) ? readme.content : readme[:content]
+            return nil if encoded.nil? || encoded.to_s.empty?
+
+            Base64.decode64(encoded).force_encoding('UTF-8')
+          rescue StandardError => e
+            warn "README fetch failed for #{repo_full_name(repo)}: #{e.message}" if verbose
+            nil
+          end
+
+          def repo_full_name(repo)
+            repo.respond_to?(:full_name) && repo.full_name ? repo.full_name : repo.name
+          end
+
+          def build_llm_adapter
+            adapter = Githuh::LLM.build
+            raise Githuh::LLM::Error, '--llm was specified but neither ANTHROPIC_API_KEY nor OPENAI_API_KEY is set' unless adapter
+
+            announce_llm(adapter) if info
+            adapter
+          end
+
+          def announce_llm(adapter)
+            provider = adapter.class.name.split('::').last
+            model    = adapter.class.const_defined?(:MODEL) ? adapter.class::MODEL : 'n/a'
+
+            puts
+            puts TTY::Box.info(
+              "LLM summaries: ENABLED\n" \
+              "Provider     : #{provider}\n" \
+              "Model        : #{model}\n" \
+              "\n" \
+              "For each repository, the README will be fetched and summarized\n" \
+              "into a 5-6 sentence description before writing to the output file.",
+              width: ui_width, padding: 1
+            )
+            puts
+          end
+
           private
 
           def filter_result!(result)
             result.reject! do |r|
               fork_reject = case forks
-              when 'exclude'
-                r.fork
-              when 'only'
-                !r.fork
-              when 'include'
-                false
-              end
+                            when 'exclude'
+                              r.fork
+                            when 'only'
+                              !r.fork
+                            when 'include'
+                              false
+                            end
 
               private_reject = case private
-              when true
-                !r.private
-              when false
-                r.private
-              when nil
-                false
-              end
+                               when true
+                                 !r.private
+                               when false
+                                 r.private
+                               when nil
+                                 false
+                               end
 
               fork_reject || private_reject
             end

data/lib/githuh/cli/commands/user/info.rb

@@ -15,9 +15,9 @@ module Githuh
         class Info < Base
           desc "Print user information"
 
-          def call(**opts)
-            super(**opts)
-            puts JSON.pretty_generate(client.user.to_hash)
+          def call(**)
+            super
+            ap client.user.to_hash
           end
         end
       end

data/lib/githuh/cli/launcher.rb

@@ -6,17 +6,17 @@ require 'tty/box'
 require 'tty/screen'
 
 require 'githuh'
+require 'githuh/cli/commands/base'
+
 module Githuh
   module CLI
     class Launcher
       attr_accessor :argv, :stdin, :stdout, :stderr, :kernel, :command
 
-      def initialize(argv, stdin = STDIN, stdout = STDOUT, stderr = STDERR, kernel = nil)
-        if ::Githuh.launcher
-          raise(ArgumentError, "Another instance of CLI Launcher was detected, aborting.")
-        else
-          Githuh.launcher = self
-        end
+      def initialize(argv, stdin = $stdin, stdout = $stdout, stderr = $stderr, kernel = nil)
+        raise(ArgumentError, "Another instance of CLI Launcher was detected, aborting.") if ::Githuh.launcher
+
+        Githuh.launcher = self
 
         self.argv   = argv
         self.stdin  = stdin
@@ -26,27 +26,26 @@ module Githuh
       end
 
       def execute!
-        if argv.empty? || !(%w(--help -h) & argv).empty?
+        if argv.empty? || !!%w(--help -h).intersect?(argv)
           stdout.puts BANNER
           Githuh.configure_kernel_behavior! help: true
         else
           Githuh.configure_kernel_behavior!
         end
 
+        # noinspection RubyYardParamTypeMatch
         self.command = ::Dry::CLI.new(::Githuh::CLI::Commands)
         command.call(arguments: argv, out: stdout, err: stderr)
       rescue StandardError => e
-        lines = [e.message.gsub(/\n/, ', ')]
-        if e.backtrace
+        lines = [e.message.gsub("\n", ', ')]
+        if e.backtrace && !!ARGV.intersect?(%w[-v --verbose])
           lines << ''
           lines.concat(e.backtrace)
         end
 
         box = TTY::Box.frame(*lines,
-                             **BOX_OPTIONS.merge(
-                               width: TTY::Screen.width,
-                               title: { top_center: "┤ #{e.class.name} ├" },
-                             ))
+                             **BOX_OPTIONS, width: TTY::Screen.width,
+                                            title: { top_center: "┤ #{e.class.name} ├" })
         stderr.puts
         stderr.print box
       ensure
@@ -59,7 +58,7 @@ module Githuh
       end
     end
 
-    BANNER = <<~BANNER
+    BANNER = <<~BANNER.freeze
 
       #{'Githuh CLI'.bold.yellow} #{::Githuh::VERSION.bold.green} — API client for Github.com.
       #{'© 2020 Konstantin Gredeskoul, All rights reserved.  MIT License.'.cyan}