git-markdown 0.1.0

data/lib/git/markdown/api/client.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module GitMarkdown
+  module Api
+    class Client
+      def initialize(base_url:, token:)
+        @base_url = base_url
+        @token = token
+      end
+
+      def get(path, params = {})
+        uri = build_uri(path, params)
+        request = Net::HTTP::Get.new(uri)
+        set_headers(request)
+
+        response = http_request(uri, request)
+        Response.new(response)
+      end
+
+      private
+
+      def build_uri(path, params)
+        uri = URI.parse("#{@base_url}#{path}")
+        uri.query = URI.encode_www_form(params) unless params.empty?
+        uri
+      end
+
+      def set_headers(request)
+        request["Authorization"] = "Bearer #{@token}"
+        request["Accept"] = "application/vnd.github.v3+json"
+        request["User-Agent"] = "git-markdown/#{GitMarkdown::VERSION}"
+      end
+
+      def http_request(uri, request)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = 10
+        http.read_timeout = 30
+
+        http.request(request)
+      rescue Net::OpenTimeout, Net::ReadTimeout => e
+        raise ApiError, "Request timeout: #{e.message}"
+      rescue => e
+        raise ApiError, "Request failed: #{e.message}"
+      end
+    end
+  end
+end

data/lib/git/markdown/api/response.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module GitMarkdown
+  module Api
+    class Response
+      attr_reader :raw_response
+
+      def initialize(response)
+        @raw_response = response
+      end
+
+      def success?
+        @raw_response.is_a?(Net::HTTPSuccess)
+      end
+
+      def not_found?
+        @raw_response.is_a?(Net::HTTPNotFound)
+      end
+
+      def unauthorized?
+        @raw_response.is_a?(Net::HTTPUnauthorized)
+      end
+
+      def data
+        return nil unless @raw_response.body
+
+        JSON.parse(@raw_response.body)
+      rescue JSON::ParserError
+        nil
+      end
+
+      def error_message
+        return nil if success?
+
+        if data && data["message"]
+          data["message"]
+        else
+          "HTTP #{@raw_response.code}: #{@raw_response.message}"
+        end
+      end
+    end
+  end
+end

data/lib/git/markdown/cli.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module GitMarkdown
+  class CLI < Thor
+    class_option :debug, type: :boolean, default: false, desc: "Enable verbose debug output"
+
+    desc "setup", "Configure git-markdown with your GitHub token"
+    def setup
+      puts "git-markdown setup"
+      puts "=================="
+      puts
+      puts "This will store your GitHub token in ~/.config/git-markdown/credentials"
+      puts
+      puts "To create a token, visit:"
+      puts "  GitHub: https://github.com/settings/personal-access-tokens"
+      puts "  (For GitLab: https://gitlab.com/-/profile/personal_access_tokens)"
+      puts
+      puts "Required permissions/scopes:"
+      puts "  - repo (for private repositories)"
+      puts "  - read:org (for organization repositories)"
+      puts "  - read:discussion (for PR discussions)"
+      puts
+      print "Enter your GitHub Personal Access Token: "
+      token = $stdin.noecho(&:gets).chomp
+      puts
+
+      if token.nil? || token.strip.empty?
+        puts "Error: Token cannot be empty"
+        exit 1
+      end
+
+      config = Configuration.new
+      config.save_credentials!(token)
+      config.save!
+
+      puts "✓ Credentials saved successfully"
+      puts "✓ Configuration saved to #{config.config_file}"
+    rescue => e
+      puts "Error: #{e.message}"
+      exit 1
+    end
+
+    desc "pr PR_IDENTIFIER", "Fetch a pull request and convert to Markdown"
+    option :output, type: :string, desc: "Output directory or file path"
+    option :stdout, type: :boolean, default: false, desc: "Output to stdout instead of file", lazy_default: true
+    option :status, type: :string, default: "unresolved", enum: %w[unresolved resolved all],
+      desc: "Filter comments by status"
+    def pr(identifier)
+      config = Configuration.load
+      owner, repo, number = parse_identifier(identifier)
+
+      debug_log(options[:debug], "Fetching PR #{owner}/#{repo}##{number}")
+      debug_log(options[:debug], "API URL: #{config.api_url}")
+
+      provider = create_provider(config)
+
+      puts "Fetching pull request..." unless options[:stdout]
+      pull_request = provider.fetch_pull_request(owner, repo, number)
+      debug_log(options[:debug], "PR title: #{pull_request.title}")
+
+      puts "Fetching comments..." unless options[:stdout]
+      comments = provider.fetch_comments(owner, repo, number)
+      debug_log(options[:debug], "Found #{comments.length} general comments")
+
+      puts "Fetching reviews..." unless options[:stdout]
+      reviews = provider.fetch_reviews(owner, repo, number)
+      debug_log(options[:debug], "Found #{reviews.length} reviews")
+
+      generator = Markdown::Generator.new(
+        pull_request,
+        comments,
+        reviews,
+        status_filter: options[:status].to_sym
+      )
+
+      markdown = generator.generate
+
+      if options[:stdout]
+        puts markdown
+      else
+        output_path = determine_output_path(options[:output], generator.filename)
+        File.write(output_path, markdown)
+        puts "✓ Saved to #{output_path}"
+      end
+    rescue AuthenticationError => e
+      puts "Authentication error: #{e.message}"
+      exit 1
+    rescue NotFoundError => e
+      puts "Not found: #{e.message}"
+      exit 1
+    rescue ApiError => e
+      puts "API error: #{e.message}"
+      debug_log(options[:debug], e.backtrace.join("\n"))
+      exit 1
+    rescue => e
+      puts "Error: #{e.message}"
+      debug_log(options[:debug], e.backtrace.join("\n"))
+      exit 1
+    end
+
+    desc "version", "Show version"
+    def version
+      puts GitMarkdown::VERSION
+    end
+
+    default_task :help
+
+    private
+
+    def parse_identifier(identifier)
+      if identifier.include?("#")
+        parts = identifier.split("#")
+        repo_parts = parts[0].split("/")
+        raise Error, "Invalid format. Use: owner/repo#123 or just 123" unless repo_parts.length == 2
+
+        [repo_parts[0], repo_parts[1], parts[1].to_i]
+
+      else
+        remote = RemoteParser.from_git_remote
+        if remote.nil? || !remote.valid?
+          raise Error, "Cannot detect repository from git remote. Use owner/repo#123 format."
+        end
+
+        [remote.owner, remote.repo, identifier.to_i]
+      end
+    end
+
+    def create_provider(config)
+      case config.provider
+      when :github
+        Providers::GitHub.new(config)
+      else
+        raise Error, "Unsupported provider: #{config.provider}"
+      end
+    end
+
+    def determine_output_path(output_option, filename)
+      if output_option.nil?
+        File.join(Dir.pwd, filename)
+      elsif File.directory?(output_option)
+        File.join(output_option, filename)
+      else
+        output_option
+      end
+    end
+
+    def debug_log(debug, message)
+      return unless debug
+
+      warn "[DEBUG] #{message}"
+    end
+  end
+end

data/lib/git/markdown/configuration.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module GitMarkdown
+  class Configuration
+    XDG_CONFIG_HOME = ENV.fetch("XDG_CONFIG_HOME", File.expand_path("~/.config"))
+    DEFAULT_PROVIDER = :github
+
+    attr_accessor :token, :provider, :api_url, :output_dir, :default_status
+
+    def initialize
+      @provider = DEFAULT_PROVIDER
+      @output_dir = Dir.pwd
+      @default_status = :unresolved
+      @api_url = nil
+    end
+
+    def self.load
+      new.load!
+    end
+
+    def load!
+      load_from_file if config_file_exist?
+      resolve_credentials
+      resolve_api_url if api_url.nil?
+      self
+    end
+
+    def config_dir
+      File.join(XDG_CONFIG_HOME, "git-markdown")
+    end
+
+    def config_file
+      File.join(config_dir, "config.yml")
+    end
+
+    def credentials_file
+      File.join(config_dir, "credentials")
+    end
+
+    def save!
+      FileUtils.mkdir_p(config_dir)
+      File.write(config_file, config_to_yaml)
+      FileUtils.chmod(0o700, config_dir)
+    end
+
+    def save_credentials!(token_value)
+      FileUtils.mkdir_p(config_dir)
+      File.write(credentials_file, token_value)
+      FileUtils.chmod(0o600, credentials_file)
+      @token = token_value
+    end
+
+    private
+
+    def config_file_exist?
+      File.exist?(config_file)
+    end
+
+    def load_from_file
+      require "yaml"
+      config = YAML.safe_load_file(
+        config_file,
+        symbolize_names: true,
+        permitted_classes: [Symbol]
+      )
+      @provider = config[:provider] if config[:provider]
+      @api_url = config[:api_url] if config[:api_url]
+      @output_dir = config[:output_dir] if config[:output_dir]
+      @default_status = config[:default_status].to_sym if config[:default_status]
+    end
+
+    def resolve_credentials
+      @token ||= Credentials.resolve(debug: false)
+    end
+
+    def resolve_api_url
+      @api_url = ENV.fetch("GITHUB_API_URL") do
+        (@provider == :github) ? "https://api.github.com" : nil
+      end
+    end
+
+    def config_to_yaml
+      {
+        provider: @provider,
+        api_url: @api_url,
+        output_dir: @output_dir,
+        default_status: @default_status
+      }.to_yaml
+    end
+  end
+end

data/lib/git/markdown/credentials.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module GitMarkdown
+  class Credentials
+    class << self
+      def resolve(debug: false)
+        token = from_env || from_git_credential || from_gh_cli || from_file
+
+        raise AuthenticationError, "No GitHub token found. Run `git-markdown setup` to configure." if token.nil?
+
+        token.strip
+      rescue => e
+        raise AuthenticationError, "Failed to resolve credentials: #{e.message}"
+      end
+
+      def from_env
+        ENV["GITHUB_TOKEN"] || ENV["GH_TOKEN"]
+      end
+
+      def from_git_credential
+        host = "github.com"
+        protocol = "https"
+
+        input = "protocol=#{protocol}\nhost=#{host}\n"
+        output = nil
+        env = {
+          "GIT_TERMINAL_PROMPT" => "0",
+          "GIT_ASKPASS" => "/bin/false",
+          "SSH_ASKPASS" => "/bin/false"
+        }
+
+        IO.popen(env, "git credential fill 2>/dev/null", "r+") do |io|
+          io.write(input)
+          io.close_write
+          output = io.read
+        end
+
+        return nil unless $?.success?
+
+        output.each_line do |line|
+          key, value = line.chomp.split("=", 2)
+          return value if key == "password"
+        end
+
+        nil
+      rescue
+        nil
+      end
+
+      def from_gh_cli
+        output = `gh auth token 2>/dev/null`
+        output.strip if $?.success? && !output.strip.empty?
+      rescue
+        nil
+      end
+
+      def from_file
+        credentials_file = File.join(
+          Configuration::XDG_CONFIG_HOME,
+          "git-markdown",
+          "credentials"
+        )
+
+        return nil unless File.exist?(credentials_file)
+
+        File.read(credentials_file).strip
+      end
+    end
+  end
+end

data/lib/git/markdown/markdown/generator.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module GitMarkdown
+  module Markdown
+    class Generator
+      def initialize(pull_request, comments, reviews, status_filter: :unresolved)
+        @pr = pull_request
+        @comments = comments
+        @reviews = reviews
+        @status_filter = status_filter
+      end
+
+      def generate
+        template = File.read(template_path)
+        erb = ERB.new(template, trim_mode: "-")
+        erb.result(binding)
+      end
+
+      def filename
+        title_slug = @pr.title.downcase.gsub(/[^a-z0-9]+/, "-").gsub(/^-|-$/, "")
+        "PR-#{@pr.number}-#{title_slug}.md"
+      end
+
+      private
+
+      def template_path
+        File.join(__dir__, "templates", "default.erb")
+      end
+
+      def format_date(date_string)
+        return nil unless date_string
+
+        Time.parse(date_string).strftime("%Y-%m-%d %H:%M UTC")
+      rescue
+        date_string
+      end
+
+      def filtered_inline_comments
+        @reviews.flat_map(&:comments).select do |comment|
+          include_comment?(comment)
+        end
+      end
+
+      def filtered_general_comments
+        @comments.select do |comment|
+          include_comment?(comment)
+        end
+      end
+
+      def include_comment?(comment)
+        case @status_filter
+        when :unresolved
+          !comment.body.include?("[resolved]") && !comment.body.include?("[done]")
+        when :resolved
+          comment.body.include?("[resolved]") || comment.body.include?("[done]")
+        else
+          true
+        end
+      end
+
+      def group_comments_by_file(comments)
+        comments.select(&:inline?).group_by(&:path)
+      end
+    end
+  end
+end

data/lib/git/markdown/markdown/templates/default.erb

@@ -0,0 +1,56 @@
+# <%= @pr.title %>
+
+**#<%= @pr.number %>** by @<%= @pr.author %> | <%= @pr.state.upcase %> | <%= format_date(@pr.created_at) %>
+
+[View on GitHub](<%= @pr.html_url %>)
+
+---
+
+<%= @pr.body %>
+
+---
+
+<% inline_comments = filtered_inline_comments %>
+<% if inline_comments.any? %>
+## Review Comments
+
+<% group_comments_by_file(inline_comments).each do |file, comments| %>
+### <%= file %>
+
+<% comments.sort_by(&:line).each do |comment| %>
+**Line <%= comment.line %>** — @<%= comment.author %> (<%= format_date(comment.created_at) %>)
+
+<%= comment.body %>
+
+---
+
+<% end %>
+<% end %>
+<% end %>
+
+<% general_comments = filtered_general_comments %>
+<% if general_comments.any? %>
+## General Comments
+
+<% general_comments.each do |comment| %>
+### @<%= comment.author %> (<%= format_date(comment.created_at) %>)
+
+<%= comment.body %>
+
+---
+
+<% end %>
+<% end %>
+
+<% if @reviews.any? { |r| r.body && !r.body.empty? } %>
+## Review Summaries
+
+<% @reviews.select { |r| r.body && !r.body.empty? }.each do |review| %>
+### @<%= review.author %> — <%= review.state %>
+
+<%= review.body %>
+
+---
+
+<% end %>
+<% end %>

data/lib/git/markdown/models/comment.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module GitMarkdown
+  module Models
+    class Comment
+      attr_reader :id, :body, :author, :path, :line, :html_url, :created_at, :updated_at, :in_reply_to_id
+
+      def initialize(attrs = {})
+        @id = attrs[:id]
+        @body = attrs[:body] || ""
+        @author = attrs[:author]
+        @path = attrs[:path]
+        @line = attrs[:line]
+        @html_url = attrs[:html_url]
+        @created_at = attrs[:created_at]
+        @updated_at = attrs[:updated_at]
+        @in_reply_to_id = attrs[:in_reply_to_id]
+      end
+
+      def self.from_api(data)
+        new(
+          id: data["id"],
+          body: data["body"],
+          author: data.dig("user", "login"),
+          path: data["path"],
+          line: data["line"] || data["original_line"],
+          html_url: data["html_url"],
+          created_at: data["created_at"],
+          updated_at: data["updated_at"],
+          in_reply_to_id: data["in_reply_to_id"]
+        )
+      end
+
+      def inline?
+        !@path.nil?
+      end
+
+      def reply?
+        !@in_reply_to_id.nil?
+      end
+    end
+  end
+end

data/lib/git/markdown/models/pull_request.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module GitMarkdown
+  module Models
+    class PullRequest
+      attr_reader :number, :title, :body, :state, :author, :html_url, :created_at, :updated_at
+
+      def initialize(attrs = {})
+        @number = attrs[:number]
+        @title = attrs[:title]
+        @body = attrs[:body] || ""
+        @state = attrs[:state]
+        @author = attrs[:author]
+        @html_url = attrs[:html_url]
+        @created_at = attrs[:created_at]
+        @updated_at = attrs[:updated_at]
+      end
+
+      def self.from_api(data)
+        new(
+          number: data["number"],
+          title: data["title"],
+          body: data["body"],
+          state: data["state"],
+          author: data.dig("user", "login"),
+          html_url: data["html_url"],
+          created_at: data["created_at"],
+          updated_at: data["updated_at"]
+        )
+      end
+
+      def open?
+        @state == "open"
+      end
+
+      def closed?
+        @state == "closed"
+      end
+    end
+  end
+end

data/lib/git/markdown/models/review.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module GitMarkdown
+  module Models
+    class Review
+      attr_reader :id, :state, :body, :author, :html_url, :submitted_at
+      attr_accessor :comments
+
+      def initialize(attrs = {})
+        @id = attrs[:id]
+        @state = attrs[:state]
+        @body = attrs[:body] || ""
+        @author = attrs[:author]
+        @html_url = attrs[:html_url]
+        @submitted_at = attrs[:submitted_at]
+        @comments = attrs[:comments] || []
+      end
+
+      def self.from_api(data)
+        new(
+          id: data["id"],
+          state: data["state"],
+          body: data["body"],
+          author: data.dig("user", "login"),
+          html_url: data["html_url"],
+          submitted_at: data["submitted_at"]
+        )
+      end
+
+      def approved?
+        @state == "APPROVED"
+      end
+
+      def changes_requested?
+        @state == "CHANGES_REQUESTED"
+      end
+
+      def commented?
+        @state == "COMMENTED"
+      end
+
+      def dismissed?
+        @state == "DISMISSED"
+      end
+    end
+  end
+end

data/lib/git/markdown/providers/base.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module GitMarkdown
+  module Providers
+    class Base
+      attr_reader :config
+
+      def initialize(config)
+        @config = config
+      end
+
+      def fetch_pull_request(owner, repo, number)
+        raise NotImplementedError
+      end
+
+      def fetch_comments(owner, repo, number)
+        raise NotImplementedError
+      end
+
+      def fetch_reviews(owner, repo, number)
+        raise NotImplementedError
+      end
+
+      def fetch_review_comments(owner, repo, review_id)
+        raise NotImplementedError
+      end
+    end
+  end
+end