github-pulse 0.2.0

data/lib/github/pulse/gh_client.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+require "open3"
+
+module Github
+  module Pulse
+    class GhClient
+      attr_reader :repo
+
+      def initialize(repo:)
+        @repo = repo
+        validate_gh_cli!
+      end
+
+      def available?
+        @gh_available
+      end
+
+      def pull_requests(since: nil, until_date: nil, state: "all")
+        limit = 1000
+        fields = "number,title,author,createdAt,closedAt,mergedAt,state,additions,deletions,changedFiles"
+        
+        cmd = ["gh", "pr", "list", "--repo", repo, "--limit", limit.to_s, "--json", fields]
+        
+        # gh doesn't support filtering by date directly, so we get all and filter
+        case state
+        when "open"
+          cmd += ["--state", "open"]
+        when "closed"
+          cmd += ["--state", "closed"]
+        when "merged"
+          cmd += ["--state", "merged"]
+        else
+          # For "all", we need to make multiple calls
+          open_prs = execute_gh_command(cmd + ["--state", "open"])
+          closed_prs = execute_gh_command(cmd + ["--state", "closed"])
+          merged_prs = execute_gh_command(cmd + ["--state", "merged"])
+          prs = open_prs + closed_prs + merged_prs
+        end
+        
+        prs ||= execute_gh_command(cmd)
+        
+        # Filter by date if needed
+        if since || until_date
+          prs = filter_by_date(prs, since, until_date) { |pr| Time.parse(pr["createdAt"]) }
+        end
+        
+        prs.map do |pr|
+          {
+            number: pr["number"],
+            title: pr["title"],
+            author: pr.dig("author", "login") || "unknown",
+            created_at: parse_time(pr["createdAt"]),
+            closed_at: parse_time(pr["closedAt"]),
+            merged_at: parse_time(pr["mergedAt"]),
+            state: pr["state"].downcase,
+            additions: pr["additions"] || 0,
+            deletions: pr["deletions"] || 0,
+            changed_files: pr["changedFiles"] || 0
+          }
+        end
+      end
+
+      def repository_info
+        fields = "name,nameWithOwner,description,createdAt,updatedAt,primaryLanguage,defaultBranchRef,diskUsage,stargazerCount,forkCount,issues"
+        cmd = ["gh", "repo", "view", repo, "--json", fields]
+        
+        data = execute_gh_command(cmd)
+        return nil unless data && !data.empty?
+        data = data.is_a?(Array) ? data.first : data
+        
+        {
+          name: data["name"],
+          full_name: data["nameWithOwner"],
+          description: data["description"],
+          created_at: parse_time(data["createdAt"]),
+          updated_at: parse_time(data["updatedAt"]),
+          language: data.dig("primaryLanguage", "name"),
+          default_branch: data.dig("defaultBranchRef", "name"),
+          size: data["diskUsage"],
+          stars: data["stargazerCount"],
+          forks: data["forkCount"],
+          open_issues: data.dig("issues", "totalCount") || 0
+        }
+      end
+
+      def commit_activity
+        # gh doesn't have a direct equivalent to commit activity stats
+        # We can get recent commits and group them by week
+        days_back = 52 * 7 # Get a year of data
+        since_date = (Date.today - days_back).to_s
+        
+        url = "repos/#{repo}/commits?since=#{since_date}"
+        cmd = ["gh", "api", url]
+        
+        commits = execute_gh_command(cmd)
+        return [] unless commits.is_a?(Array)
+        
+        # Group by week
+        activity = Hash.new(0)
+        commits.each do |commit|
+          date_str = commit.dig("commit", "author", "date")
+          next unless date_str
+          
+          date = Date.parse(date_str)
+          week_start = date - date.cwday + 1
+          activity[week_start] += 1
+        end
+        
+        activity.map do |week_start, count|
+          days = [0] * 7
+          # We don't have daily granularity from this API, so distribute evenly
+          days[0] = count
+          
+          {
+            week_start: week_start,
+            days: days,
+            total: count
+          }
+        end
+      end
+      
+      def commits_data(since: nil, until_date: nil)
+        # Fetch commit data from GitHub
+        # Build query string for parameters
+        params = []
+        params << "since=#{since}" if since
+        params << "until=#{until_date}" if until_date
+        
+        url = "repos/#{repo}/commits"
+        url += "?#{params.join('&')}" unless params.empty?
+        
+        cmd = ["gh", "api", url]
+        
+        commits = execute_gh_command(cmd)
+        
+        # Group commits by author
+        commits_by_author = Hash.new { |h, k| h[k] = [] }
+        
+        commits.each do |commit|
+          author = commit.dig("author", "login") || commit.dig("commit", "author", "email") || "unknown"
+          
+          commits_by_author[author] << {
+            sha: commit["sha"],
+            message: commit.dig("commit", "message")&.lines&.first&.strip,
+            time: parse_time(commit.dig("commit", "author", "date")),
+            additions: 0,  # GitHub API doesn't provide this in commits list
+            deletions: 0   # Would need individual commit API calls
+          }
+        end
+        
+        commits_by_author
+      end
+
+      def contributors_stats
+        # Use gh api to get contributor statistics
+        cmd = ["gh", "api", "repos/#{repo}/stats/contributors", "--cache", "1h"]
+        
+        stats = execute_gh_command(cmd)
+        return [] unless stats && stats.is_a?(Array)
+        
+        stats.map do |contributor|
+          {
+            author: contributor.dig("author", "login") || "unknown",
+            total_commits: contributor["total"],
+            weeks: (contributor["weeks"] || []).map do |week|
+              {
+                week_start: Time.at(week["w"]).to_date,
+                additions: week["a"],
+                deletions: week["d"],
+                commits: week["c"]
+              }
+            end
+          }
+        end
+      end
+
+      private
+
+      def validate_gh_cli!
+        # Check if gh is installed
+        _, _, status = Open3.capture3("which", "gh")
+        unless status.success?
+          @gh_available = false
+          return
+        end
+        
+        # Check if gh is authenticated
+        _, stderr, status = Open3.capture3("gh", "auth", "status")
+        if status.success? || stderr.include?("Logged in")
+          @gh_available = true
+        else
+          @gh_available = false
+        end
+      rescue StandardError
+        @gh_available = false
+      end
+
+      def execute_gh_command(cmd)
+        stdout, stderr, status = Open3.capture3(*cmd)
+        
+        # For paginated requests, gh may return partial success
+        # Check if we got any data even if status indicates an error
+        if !stdout.strip.empty?
+          begin
+            # Try to parse the output we did get
+            result = JSON.parse(stdout)
+            return result
+          rescue JSON::ParserError
+            # Some gh api commands return newline-delimited JSON
+            return stdout.lines.map { |line| JSON.parse(line.strip) rescue nil }.compact
+          end
+        end
+        
+        unless status.success?
+          if stderr.include?("HTTP 404") || stderr.include?("not found")
+            return []
+          end
+          raise Error, "gh command failed: #{stderr}"
+        end
+        
+        []
+      end
+
+      def filter_by_date(items, since, until_date)
+        items.select do |item|
+          date = yield(item)
+          next false unless date
+          
+          date_check = true
+          date_check &&= date >= Time.parse(since) if since
+          date_check &&= date <= Time.parse(until_date) if until_date
+          date_check
+        end
+      end
+
+      def parse_time(time_str)
+        return nil unless time_str
+        Time.parse(time_str)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/github/pulse/git_analyzer.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require "rugged"
+require "time"
+
+module Github
+  module Pulse
+    class GitAnalyzer
+      attr_reader :repository, :repo_path
+
+      def initialize(repo_path)
+        @repo_path = repo_path
+        @repository = Rugged::Repository.new(repo_path)
+      rescue Rugged::RepositoryError => e
+        raise Error, "Not a valid git repository: #{repo_path}"
+      end
+
+      def analyze_commits(since: nil, until_date: nil)
+        walker = Rugged::Walker.new(repository)
+        walker.push(repository.head.target_id)
+        
+        commits_by_author = Hash.new { |h, k| h[k] = [] }
+        
+        walker.each do |commit|
+          commit_time = Time.at(commit.time)
+          
+          if since && commit_time < Time.parse(since)
+            break
+          end
+          
+          if until_date && commit_time > Time.parse(until_date)
+            next
+          end
+          
+          author = commit.author[:email]
+          commits_by_author[author] << {
+            sha: commit.oid,
+            message: commit.message.lines.first&.strip,
+            time: commit_time,
+            additions: 0,
+            deletions: 0
+          }
+        end
+        
+        commits_by_author.each do |author, commits|
+          commits.each do |commit_data|
+            stats = calculate_commit_stats(commit_data[:sha])
+            commit_data[:additions] = stats[:additions]
+            commit_data[:deletions] = stats[:deletions]
+          end
+        end
+        
+        commits_by_author
+      end
+
+      def lines_of_code_by_author
+        blame_data = Hash.new(0)
+        
+        repository.head.target.tree.walk(:preorder) do |root, entry|
+          next unless entry[:type] == :blob
+          
+          file_path = root.empty? ? entry[:name] : "#{root}/#{entry[:name]}"
+          
+          next if binary_file?(file_path)
+          
+          begin
+            blame = Rugged::Blame.new(repository, file_path)
+            blame.each do |hunk|
+              author = hunk[:final_signature][:email]
+              lines = hunk[:lines_in_hunk]
+              blame_data[author] += lines
+            end
+          rescue StandardError
+            next
+          end
+        end
+        
+        blame_data
+      end
+
+      def commit_activity_by_day
+        walker = Rugged::Walker.new(repository)
+        walker.push(repository.head.target_id)
+        
+        activity = Hash.new(0)
+        
+        walker.each do |commit|
+          date = Time.at(commit.time).to_date
+          activity[date] += 1
+        end
+        
+        activity.sort.to_h
+      end
+
+      def remote_url
+        remotes = repository.remotes
+        return nil if remotes.count == 0
+        
+        origin = remotes["origin"]
+        return nil unless origin
+        
+        url = origin.url
+        extract_github_repo(url)
+      end
+
+      private
+
+      def calculate_commit_stats(sha)
+        commit = repository.lookup(sha)
+        
+        if commit.parents.empty?
+          tree = commit.tree
+          stats = { additions: 0, deletions: 0 }
+          
+          tree.walk(:preorder) do |root, entry|
+            next unless entry[:type] == :blob
+            blob = repository.lookup(entry[:oid])
+            stats[:additions] += blob.content.lines.count
+          end
+          
+          stats
+        else
+          parent = commit.parents.first
+          diff = parent.diff(commit)
+          
+          stats = { additions: 0, deletions: 0 }
+          diff.each_patch do |patch|
+            patch.hunks.each do |hunk|
+              hunk.lines.each do |line|
+                case line.line_origin
+                when :addition
+                  stats[:additions] += 1
+                when :deletion
+                  stats[:deletions] += 1
+                end
+              end
+            end
+          end
+          
+          stats
+        end
+      rescue StandardError
+        { additions: 0, deletions: 0 }
+      end
+
+      def binary_file?(path)
+        extensions = %w[.jpg .jpeg .png .gif .pdf .zip .tar .gz .exe .dll .so .dylib .o .a]
+        extensions.any? { |ext| path.downcase.end_with?(ext) }
+      end
+
+      def extract_github_repo(url)
+        patterns = [
+          %r{github\.com[:/]([^/]+/[^/]+?)(?:\.git)?$},
+          %r{git@github\.com:([^/]+/[^/]+?)(?:\.git)?$}
+        ]
+        
+        patterns.each do |pattern|
+          if match = url.match(pattern)
+            return match[1]
+          end
+        end
+        
+        nil
+      end
+    end
+  end
+end

data/lib/github/pulse/github_client.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "octokit"
+require "time"
+
+module Github
+  module Pulse
+    class GithubClient
+      attr_reader :client, :repo
+
+      def initialize(repo:, token: nil)
+        @repo = repo
+        @client = if token
+                    Octokit::Client.new(access_token: token)
+                  else
+                    Octokit::Client.new
+                  end
+        @client.auto_paginate = true
+      end
+
+      def pull_requests(since: nil, until_date: nil, state: "all")
+        prs = client.pull_requests(repo, state: state)
+        
+        if since || until_date
+          prs = filter_by_date(prs, since, until_date, &:created_at)
+        end
+        
+        prs.map do |pr|
+          {
+            number: pr.number,
+            title: pr.title,
+            author: pr.user.login,
+            created_at: pr.created_at,
+            closed_at: pr.closed_at,
+            merged_at: pr.merged_at,
+            state: pr.state,
+            additions: pr.additions || 0,
+            deletions: pr.deletions || 0,
+            changed_files: pr.changed_files || 0
+          }
+        end
+      end
+
+      def contributors_stats
+        stats = client.contributors_stats(repo)
+        return [] unless stats
+        
+        stats.map do |contributor|
+          {
+            author: contributor.author.login,
+            total_commits: contributor.total,
+            weeks: contributor.weeks.map do |week|
+              {
+                week_start: Time.at(week.w).to_date,
+                additions: week.a,
+                deletions: week.d,
+                commits: week.c
+              }
+            end
+          }
+        end
+      rescue Octokit::Accepted => e
+        sleep 2
+        retry
+      end
+
+      def commit_activity
+        activity = client.commit_activity_stats(repo)
+        return [] unless activity
+        
+        activity.map do |week|
+          {
+            week_start: Time.at(week.week).to_date,
+            days: week.days,
+            total: week.total
+          }
+        end
+      rescue Octokit::Accepted => e
+        sleep 2
+        retry
+      end
+
+      def repository_info
+        repo_data = client.repository(repo)
+        {
+          name: repo_data.name,
+          full_name: repo_data.full_name,
+          description: repo_data.description,
+          created_at: repo_data.created_at,
+          updated_at: repo_data.updated_at,
+          language: repo_data.language,
+          default_branch: repo_data.default_branch,
+          size: repo_data.size,
+          stars: repo_data.stargazers_count,
+          forks: repo_data.forks_count,
+          open_issues: repo_data.open_issues_count
+        }
+      end
+
+      private
+
+      def filter_by_date(items, since, until_date)
+        items.select do |item|
+          date = yield(item)
+          next false unless date
+          
+          date_check = true
+          date_check &&= date >= Time.parse(since) if since
+          date_check &&= date <= Time.parse(until_date) if until_date
+          date_check
+        end
+      end
+    end
+  end
+end