nya_pr 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 74fef078ebf20c6a46a8596b5001a66b744436a33ee407d14168699e577fa7e1
+  data.tar.gz: 3e686721cb075eead9c7cd7070cf49ee6d0b9eca7ce879b8555380c6d1a52626
+SHA512:
+  metadata.gz: 40aa1079ac60ac7d0de2d79135eeb75f7b1854e4299277a94ec424268d0fb59719be1f8832546fb6fd28abeac63786b4043a2128ea60749daa183839850658f3
+  data.tar.gz: 0377b72b765df89b9da1ff33d92224431a1ebe16c10c70e457f4ebdb93381479d9c1a6e0122366075363f1d550ca1491647d9f0cd9b44347d9cca6304249806e

data/LICENSE.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Elijah S. Krukowski
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,314 @@
+# NyaPr ฅ^•ﻌ•^ฅ
+
+**NyaPr** is a tiny Ruby tool for people who have too many GitHub repositories, too many organizations, too many pull requests, and absolutely no desire to click through all that manually.
+
+It collects repositories you own or contribute to, finds their open pull requests, and puts everything into one place.
+
+For maximum kawaii.
+
+## Why NyaPr?
+
+GitHub is perfectly happy to show you:
+
+* all repositories in a giant organization;
+* pull requests you authored;
+* pull requests where somebody mentioned you;
+* approximately seventeen billion other things.
+
+What it does not make particularly convenient is:
+
+> Show me open pull requests from my own repositories **plus** repositories in these organizations where I actually contribute.
+
+NyaPr does exactly that.
+
+The basic flow is:
+
+```text
+GitHub users / organizations
+        ↓
+collect repositories
+        ↓
+keep repositories you actually contribute to
+        ↓
+optionally skip archived repositories
+        ↓
+cache the repository list
+        ↓
+find open pull requests
+        ↓
+terminal + timestamped CSV
+        ↓
+nya ฅ^•ﻌ•^ฅ
+```
+
+## Requirements
+
+* Ruby 4+
+* A GitHub personal access token
+* A reasonable appreciation of cats
+
+## Setup
+
+Install the dependencies:
+
+```bash
+bundle install
+```
+
+Create a `.env` file:
+
+```text
+GITHUB_TOKEN=your_github_token
+```
+
+For private repositories, make sure the token has access to them. If an organization uses SSO, the token may also need to be authorized for that organization.
+
+## Usage
+
+Run NyaPr with your GitHub username:
+
+```bash
+ruby run.rb --user bodrovis
+```
+
+You can also provide additional users or organizations whose repositories should be inspected:
+
+```bash
+ruby run.rb \
+  --user bodrovis \
+  --owners org1,org2
+```
+
+Your own repositories are always included automatically.
+
+For other users and organizations, NyaPr checks which repositories contain commits authored by the specified GitHub user.
+
+## Data directory
+
+By default, NyaPr stores generated data inside the `data` directory.
+
+The repository cache is stored as:
+
+```text
+data/repositories.csv
+```
+
+Each pull request scan gets its own timestamped directory:
+
+```text
+data/
+├── repositories.csv
+├── pull_requests_20260912_201845/
+│   └── pull_requests.csv
+└── pull_requests_20260912_204112/
+    └── pull_requests.csv
+```
+
+This keeps repository discovery cached while preserving the results of individual pull request scans.
+
+Missing directories are created automatically.
+
+## Repository cache
+
+Repository discovery can involve a lot of GitHub API requests, especially for large organizations.
+
+NyaPr therefore stores discovered repositories in:
+
+```text
+data/repositories.csv
+```
+
+On subsequent runs, this file is used as a cache instead of scanning GitHub again.
+
+To force a fresh repository scan:
+
+```bash
+ruby run.rb \
+  --user bodrovis \
+  --owners org1,org2 \
+  --refresh
+```
+
+You can use another repository cache file:
+
+```bash
+ruby run.rb \
+  --user bodrovis \
+  --repositories-csv "C:\Users\me\repositories.csv"
+```
+
+Both relative and absolute paths are supported.
+
+Repository contribution checks are performed concurrently using a small thread pool, because waiting for hundreds of HTTP requests one by one is not particularly kawaii.
+
+## Skipping archived repositories
+
+Archived repositories are usually ancient tombs where pull requests go to sleep forever.
+
+You can ignore them completely:
+
+```bash
+ruby run.rb \
+  --user bodrovis \
+  --owners org1,org2 \
+  --skip-archived
+```
+
+When this option is enabled, archived repositories are removed before expensive contribution checks are performed.
+
+Maximum efficiency. Minimum archaeology.
+
+## Pull requests
+
+After preparing the repository list, NyaPr searches each repository for open pull requests.
+
+Results are grouped by repository and printed to the terminal:
+
+```text
+bodrovis/example
+----------------
+
+#42 Fix pagination
+  Author: @someone
+  https://github.com/bodrovis/example/pull/42
+
+#43 [DRAFT] Add nya support
+  Author: @someone_else
+  https://github.com/bodrovis/example/pull/43
+```
+
+They are also written to a timestamped CSV file:
+
+```text
+data/pull_requests_20260912_201845/pull_requests.csv
+```
+
+The CSV contains:
+
+```text
+repository
+number
+title
+author
+draft
+created_at
+updated_at
+html_url
+```
+
+By default, NyaPr stops after collecting **100 open pull requests**.
+
+You can change the limit with `--limit`:
+
+```bash
+ruby run.rb \
+  --user bodrovis \
+  --limit 250
+```
+
+You can also change the base directory where pull request runs are stored:
+
+```bash
+ruby run.rb \
+  --user bodrovis \
+  --pull-requests-dir "C:\Users\me\nya-results"
+```
+
+This produces something like:
+
+```text
+C:\Users\me\nya-results\pull_requests_20260912_201845\pull_requests.csv
+```
+
+Each run still gets its own timestamped directory.
+
+## Logging
+
+NyaPr uses normal log levels instead of spraying random `puts` statements everywhere like an animal.
+
+The default level is `info`.
+
+Example:
+
+```bash
+ruby run.rb \
+  --user bodrovis \
+  --owners org1,org2 \
+  --log-level info
+```
+
+At the `info` level, NyaPr reports the major stages of the run: loading or discovering repositories, filtering contributions, searching for pull requests, and saving results.
+
+For HTTP-level details:
+
+```bash
+ruby run.rb ... --log-level debug
+```
+
+This also shows requests, responses, skipped empty repositories, detected contributions, and other useful diagnostic information.
+
+Available levels:
+
+```text
+debug
+info
+warn
+error
+fatal
+```
+
+Logs are written to `stderr`, while actual pull request output goes to `stdout`.
+
+## CLI options
+
+```text
+-u, --user USERNAME              GitHub username
+-o, --owners LIST                Additional users or organizations, comma-separated
+    --token TOKEN                GitHub token (GITHUB_TOKEN env variable is recommended)
+    --repositories-csv PATH      Repository cache CSV path
+    --pull-requests-dir PATH     Directory for pull request runs
+-l, --limit N                    Maximum number of pull requests to collect
+-r, --refresh                    Refresh repositories from GitHub
+    --skip-archived              Ignore archived repositories
+    --[no-]progress              Show or hide progress bars
+    --log-level LEVEL            Logging level
+-v, --version                    Show NyaPr version
+```
+
+Example with most options enabled:
+
+```bash
+ruby run.rb \
+  --user bodrovis \
+  --owners org1,org2 \
+  --repositories-csv "data/repositories.csv" \
+  --pull-requests-dir "data" \
+  --limit 250 \
+  --skip-archived \
+  --refresh \
+  --log-level debug
+```
+
+## How repository discovery works
+
+For your own GitHub username, NyaPr collects repositories owned by your authenticated account.
+
+For additional owners:
+
+1. NyaPr determines whether the owner is a GitHub user or organization.
+2. It collects their repositories.
+3. Archived repositories can optionally be removed.
+4. NyaPr checks whether your GitHub user has commits in each repository.
+5. Only repositories where you contributed are retained.
+
+Contribution checks run concurrently using a limited number of worker threads.
+
+Empty Git repositories are simply skipped.
+
+Repositories with pull requests disabled are also skipped when searching for PRs.
+
+The prepared repository list is cached, but pull requests are fetched fresh on every run.
+
+## License
+
+(c) [Elijah S. Krukowski](https://bodrovis.tech), MIT license

data/exe/nya-pr

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'nya_pr'
+
+begin
+  NyaPr.run
+rescue OptionParser::ParseError, NyaPr::Error => e
+  warn "nya-pr: #{e.message}"
+  exit 1
+rescue Interrupt
+  warn "\nnya-pr: interrupted"
+  exit 130
+end

data/lib/nya_pr/cli/command.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module NyaPr
+  module Cli
+    class Command < Dry::CLI::Command
+      LOG_LEVELS = {
+        'debug' => Logger::DEBUG,
+        'info' => Logger::INFO,
+        'warn' => Logger::WARN,
+        'error' => Logger::ERROR,
+        'fatal' => Logger::FATAL
+      }.freeze
+
+      desc 'Collect open GitHub pull requests'
+
+      option :username,
+             aliases: ['-u', '--user'],
+             desc: 'GitHub username'
+
+      option :owners,
+             aliases: ['-o'],
+             type: :array,
+             default: [],
+             desc: 'Repository owners'
+
+      option :token,
+             desc: 'GitHub token'
+
+      option :repositories_csv,
+             desc: 'Repository cache CSV path'
+
+      option :pull_requests_dir,
+             desc: 'Directory for pull request runs'
+
+      option :limit,
+             aliases: ['-l'],
+             default: PullRequest::Finder::MAX_PULL_REQUESTS,
+             desc: 'Maximum number of pull requests'
+
+      option :refresh,
+             aliases: ['-r'],
+             type: :boolean,
+             default: false,
+             desc: 'Refresh repositories from GitHub'
+
+      option :skip_archived,
+             type: :boolean,
+             default: false,
+             desc: 'Skip archived repositories'
+
+      option :progress,
+             type: :boolean,
+             default: true,
+             desc: 'Show progress bars'
+
+      option :log_level,
+             values: LOG_LEVELS.keys,
+             default: 'info',
+             desc: 'Log level'
+
+      option :version,
+             aliases: ['-v'],
+             type: :flag,
+             desc: 'Show version'
+
+      def call(version: false, **options)
+        if version
+          puts NyaPr::VERSION
+          return
+        end
+
+        normalize_options!(options)
+        validate_username!(options)
+
+        Runner.new(options).run
+      end
+
+      private
+
+      def normalize_options!(options)
+        options[:owners] = normalize_owners(options[:owners])
+        options[:limit] = normalize_limit(options[:limit])
+        options[:log_level] = LOG_LEVELS.fetch(options[:log_level])
+      end
+
+      def normalize_owners(owners)
+        Array(owners).
+          flat_map { |owner| owner.split(',') }.
+          map(&:strip).
+          reject(&:empty?)
+      end
+
+      def normalize_limit(value)
+        limit = Integer(value)
+
+        return limit if limit.positive?
+
+        raise NyaPr::Error, 'limit must be greater than 0'
+      rescue ArgumentError, TypeError
+        raise NyaPr::Error, 'limit must be a positive integer'
+      end
+
+      def validate_username!(options)
+        return unless options[:username].to_s.empty?
+
+        raise NyaPr::Error, 'GitHub username is required'
+      end
+    end
+  end
+end

data/lib/nya_pr/client.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module NyaPr
+  class Client
+    attr_reader :token, :options
+
+    def initialize(token, **options)
+      @token = token
+      @options = options
+    end
+  end
+end

data/lib/nya_pr/connection.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'faraday'
+
+module NyaPr
+  module Connection
+    API_URL = 'https://api.github.com'
+    API_VERSION = '2026-03-10'
+
+    def connection(client)
+      Faraday.new(connection_options(client)) do |faraday|
+        faraday.adapter Faraday.default_adapter
+      end
+    end
+
+    private
+
+    def connection_options(client)
+      {
+        url: API_URL,
+        headers: {
+          accept: 'application/vnd.github+json',
+          user_agent: "nya_pr gem/#{NyaPr::VERSION}",
+          authorization: "Bearer #{client.token}",
+          'X-GitHub-Api-Version': client.options.fetch(:api_version, API_VERSION)
+        },
+        request: {
+          timeout: client.options.fetch(:timeout, 60),
+          open_timeout: client.options.fetch(:open_timeout, 10)
+        }
+      }
+    end
+  end
+end

data/lib/nya_pr/error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module NyaPr
+  class Error < StandardError
+    attr_reader :status
+
+    def initialize(message, status: nil)
+      @status = status
+
+      super(message)
+    end
+  end
+end

data/lib/nya_pr/paths.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module NyaPr
+  class Paths
+    DEFAULT_DATA_DIR = 'data'
+    REPOSITORIES_FILENAME = 'repositories.csv'
+    PULL_REQUESTS_FILENAME = 'pull_requests.csv'
+
+    attr_reader :repositories_path, :pull_requests_dir
+
+    def initialize(
+      repositories_path: nil,
+      pull_requests_dir: nil,
+      timestamp: Time.now
+    )
+      @repositories_path = repositories_path
+      @pull_requests_dir = pull_requests_dir
+      @timestamp = timestamp
+    end
+
+    def repositories_csv
+      path = Pathname.new(
+        repositories_path || File.join(DEFAULT_DATA_DIR, REPOSITORIES_FILENAME)
+      )
+
+      prepare_parent(path)
+      path.to_s
+    end
+
+    def pull_requests_csv
+      path = pull_requests_run_dir.join(PULL_REQUESTS_FILENAME)
+
+      FileUtils.mkdir_p(path.dirname)
+
+      path.to_s
+    end
+
+    private
+
+    attr_reader :timestamp
+
+    def pull_requests_run_dir
+      @pull_requests_run_dir ||= begin
+        base = Pathname.new(pull_requests_dir || DEFAULT_DATA_DIR)
+
+        base.join("pull_requests_#{formatted_timestamp}")
+      end
+    end
+
+    def formatted_timestamp
+      timestamp.strftime('%Y%m%d_%H%M%S')
+    end
+
+    def prepare_parent(path)
+      FileUtils.mkdir_p(path.dirname)
+    end
+  end
+end

data/lib/nya_pr/progress.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module NyaPr
+  class Progress
+    DEFAULT_WIDTH = 30
+
+    attr_reader :title, :total, :width, :output
+
+    def initialize(
+      title,
+      total:,
+      enabled: true,
+      width: DEFAULT_WIDTH,
+      output: $stderr
+    )
+      @title = title
+      @total = total
+      @width = width
+      @output = output
+      @enabled = enabled
+      @current = 0
+      @started_at = monotonic_time
+      @mutex = Mutex.new
+
+      render if enabled?
+    end
+
+    def advance(step = 1)
+      return unless enabled?
+
+      mutex.synchronize do
+        @current = [@current + step, total].min
+        render
+      end
+    end
+
+    def finish
+      return unless enabled?
+
+      mutex.synchronize do
+        render
+        output.puts
+        output.flush
+      end
+    end
+
+    private
+
+    attr_reader :current, :started_at, :mutex
+
+    def enabled?
+      @enabled && total.positive?
+    end
+
+    def render
+      output.print(
+        "\r\e[2K",
+        title,
+        ' [',
+        progress_bar,
+        '] ',
+        "#{current}/#{total} ",
+        "#{percentage}% ",
+        "ETA #{eta}"
+      )
+
+      output.flush
+    end
+
+    def progress_bar
+      completed = (width * progress).round
+      remaining = width - completed
+
+      ('█' * completed) + ('░' * remaining)
+    end
+
+    def progress
+      current.to_f / total
+    end
+
+    def percentage
+      (progress * 100).round
+    end
+
+    def eta
+      return '--' if current.zero?
+
+      elapsed = monotonic_time - started_at
+      rate = current / elapsed
+
+      return '--' unless rate.positive?
+
+      seconds = ((total - current) / rate).round
+
+      format_duration(seconds)
+    end
+
+    def format_duration(seconds)
+      return "#{seconds}s" if seconds < 60
+
+      minutes, seconds = seconds.divmod(60)
+
+      "#{minutes}m #{seconds.to_s.rjust(2, '0')}s"
+    end
+
+    def monotonic_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end