github-daily-digest 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5f607d1a7a04aa2735c14f7d6872c348efa10aa74c7a91296a35fd39e6705be8
+  data.tar.gz: b4d1d4e1de8ede127a6844919736afb6f5805ea29b6a8e2606bba3371c18bb92
+SHA512:
+  metadata.gz: cf2f46d7f565b40c1731e1386a6eaa394947be98168befd7f59dc805ed0f7864bf01d34bb7e38be47fdb9b99f7a8b6e174fbd119eb768540c4ec1072b3105608
+  data.tar.gz: 2ee9c02d0ccab93af5870ecee1525fdd4140f1b9723a0bfd231f3af4e18117db77477553062b17ad281debfbcbdee6fd227785d47dd5735f9c27da4b1dfe3aeb

data/README.md

@@ -0,0 +1,35 @@
+# GithubDailyDigest
+
+TODO: Delete this and the text below, and describe your gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/github_daily_digest`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## Installation
+
+TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/github_daily_digest.

data/Rakefile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+task default: %i[]

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "github-daily-digest"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require "irb"
+IRB.start(__FILE__)

data/bin/github-daily-digest

@@ -0,0 +1,140 @@
+#!/usr/bin/env ruby
+
+# This script uses the github_daily_digest gem to run the daily analysis.
+
+# --- Optional: Load .env for convenience if dotenv gem is available ---
+# This allows users to manage secrets via .env when running the executable,
+# but the core gem library doesn't depend on it.
+begin
+  require 'dotenv/load'
+  # Don't print this in json-only mode
+rescue LoadError
+  # dotenv gem not found, proceed using environment variables set externally.
+end
+# --------------------------------------------------------------------
+
+# Add the lib directory to the load path for running from the repository
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+
+require 'github-daily-digest' # Load the gem's code from lib/
+require 'logger'
+require 'json'
+require 'fileutils'
+
+begin
+  # Load Configuration with command-line arguments
+  config = GithubDailyDigest::Configuration.new(ARGV)
+  
+  # Show help and exit if requested
+  if config.help_requested
+    puts config.help_text
+    exit(0)
+  end
+
+  # Setup Logger based on configuration
+  logger = if config.output_to_stdout
+    # Use STDOUT for direct output
+    logger = Logger.new(STDOUT)
+    # Format logs without timestamps when outputting to terminal
+    logger.formatter = proc do |severity, datetime, progname, msg|
+      config.json_only ? "" : "[#{severity.ljust(5)}]: #{msg}\n"
+    end
+    logger
+  else
+    # Traditional log file if explicitly requested
+    log_file_path = File.expand_path('daily_digest.log', Dir.pwd)
+    logger = Logger.new(log_file_path, 'daily', 7)
+    logger.formatter = proc do |severity, datetime, progname, msg|
+      "#{datetime.strftime('%Y-%m-%d %H:%M:%S')} [#{severity.ljust(5)}]: #{msg}\n"
+    end
+    puts "Logging to: #{log_file_path}"
+    logger
+  end
+  
+  logger.level = Logger.const_get(config.log_level)
+  
+  # Only output this in verbose mode
+  logger.info("Starting GitHub Daily Digest") unless config.json_only
+
+rescue ArgumentError => e
+  # Configuration errors (missing ENV vars, invalid formats)
+  if config&.json_only
+    puts JSON.pretty_generate({ error: e.message })
+  else
+    puts "Error: #{e.message}"
+    puts "Use --help for usage information"
+  end
+  exit(1)
+rescue => e
+  # Catch other potential setup errors
+  if config&.json_only
+    puts JSON.pretty_generate({ error: e.message })
+  else
+    puts "Initialization Error: #{e.message}"
+    puts e.backtrace.join("\n")
+  end
+  exit(1)
+end
+
+# --- Main Execution ---
+begin
+  # Only output this in verbose mode
+  logger.info("Results will be output directly") unless config.json_only
+  
+  # Create the runner with our configuration
+  runner = GithubDailyDigest::DailyDigestRunner.new(config: config, logger: logger)
+  
+  # Run and get the results
+  results = runner.run
+  
+  # Output results in proper format and destination
+  output_formatter = GithubDailyDigest::OutputFormatter.new(config: config, logger: logger)
+  formatted_output = output_formatter.format(results)
+  
+  # Send to correct destination
+  if config.output_to_stdout
+    # Just output to stdout
+    puts formatted_output
+  else
+    # Save to a log file
+    results_dir = File.expand_path('results', Dir.pwd)
+    FileUtils.mkdir_p(results_dir)
+    
+    # Create appropriate filename with format extension
+    format_ext = config.output_format == 'markdown' ? 'md' : 'json'
+    results_file = File.join(results_dir, "daily_digest_#{Time.now.strftime('%Y%m%d_%H%M%S')}.#{format_ext}")
+    File.write(results_file, formatted_output)
+    logger.info("Results saved to #{results_file}")
+  end
+  
+  logger.info("Execution finished successfully.") unless config.json_only
+  
+  exit(0)
+rescue => e
+  # Handle errors during execution
+  if config&.output_formats&.include?('markdown')
+    error_output = "# Error\n\n"
+    error_output << "**Error Message:** #{e.message}\n\n"
+    error_output << "**Stack Trace:**\n\n```\n#{e.backtrace.join("\n")}\n```\n" unless config&.json_only
+    
+    if config&.output_to_stdout
+      puts error_output
+    else
+      # Try to write to a log file
+      begin
+        results_dir = File.expand_path('results', Dir.pwd)
+        FileUtils.mkdir_p(results_dir)
+        results_file = File.join(results_dir, "error_#{Time.now.strftime('%Y%m%d_%H%M%S')}.md")
+        File.write(results_file, error_output)
+        puts "Error details saved to #{results_file}"
+      rescue
+        puts error_output
+      end
+    end
+  else # Default to JSON
+    error_json = { error: e.message }
+    error_json[:backtrace] = e.backtrace unless config&.json_only
+    puts JSON.pretty_generate(error_json)
+  end
+  exit(1)
+end

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/github-daily-digest.gemspec

@@ -0,0 +1,47 @@
+# github_daily_digest/github-daily-digest.gemspec
+require_relative "lib/github-daily-digest/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "github-daily-digest"
+  spec.version       = GithubDailyDigest::VERSION
+  spec.authors       = ["Arturas Piksrys"]
+  spec.email         = ["arturas@wisemonks.com"] 
+
+  spec.summary       = "Generates daily activity digests for GitHub organization members using Gemini."
+  spec.description   = "Fetches recent GitHub commits and PR reviews for organization members and uses Google's Gemini API to analyze and summarize the activity. Provides an executable for daily runs."
+  spec.homepage      = "https://github.com/wisemonks/github-daily-digest" 
+  spec.license       = "MIT" 
+  spec.required_ruby_version = ">= 2.7.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage # Assumes source is at homepage
+  # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here." # Optional
+
+  # Specify which files should be added to the gem when it is packaged.
+  # Note: Excludes test files, .env, logs, results, etc.
+  spec.files = Dir[
+    'lib/**/*',
+    'bin/*',
+    'README.md',
+    'LICENSE',
+    'Rakefile',
+    'github-daily-digest.gemspec',
+    'github-daily-digest.rb'
+  ]
+  spec.bindir        = "bin" # Directory for executables
+  spec.executables   = spec.files.grep(%r{\Abin/}) { |f| File.basename(f) } # Find executables in bin/
+  spec.require_paths = ["lib"] # Code is loaded from the lib directory
+
+  # Runtime Dependencies: Gems required for the gem to function
+  spec.add_dependency "activesupport", "~> 7.0" # Or your preferred version constraint
+  spec.add_dependency "gemini-ai", "~> 4.2"
+  spec.add_dependency "logger" # Standard lib, but good practice to list
+  spec.add_dependency "octokit", "~> 6.1"
+  spec.add_dependency "graphql-client", "~> 0.19.0"
+
+  # Development Dependencies: Gems needed for development/testing (managed by Gemfile)
+  spec.add_development_dependency "bundler", ">= 2.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  # spec.add_development_dependency "rspec", "~> 3.0" # If you add tests
+  spec.add_development_dependency "dotenv", "~> 2.8" # Needed by the *executable* for convenience
+end

data/github-daily-digest.rb

@@ -0,0 +1,20 @@
+# github_daily_digest/lib/github_daily_digest.rb
+require "logger"
+require "active_support/all"
+require "octokit"
+require "gemini-ai"
+require "json"
+require "time"
+
+# Order matters for relative requires if classes depend on each other during load
+require_relative "lib/github_daily_digest/version"
+require_relative "lib/configuration"
+require_relative "lib/github_service"
+require_relative "lib/github_graphql_service"
+require_relative "lib/gemini_service"
+require_relative "lib/activity_analyzer"
+require_relative "lib/daily_digest_runner"
+
+module GithubDailyDigest
+  class Error < StandardError; end
+end

data/lib/activity_analyzer.rb

@@ -0,0 +1,48 @@
+# github_daily_digest/lib/activity_analyzer.rb
+require_relative './language_analyzer.rb'
+module GithubDailyDigest
+  class ActivityAnalyzer
+    def initialize(gemini_service:, github_graphql_service:, logger:)
+      @gemini_service = gemini_service
+      @github_graphql_service = github_graphql_service
+      @logger = logger
+    end
+
+    def analyze(username:, activity_data:, time_window_days: 7)
+      @logger.info("Analyzing activity for user: #{username}")
+      commits = activity_data[:commits]
+      review_count = activity_data[:review_count]
+
+      commits_with_code = if @github_graphql_service
+                          @github_graphql_service.fetch_commits_changes(commits)
+                        else
+                          @logger.debug("GraphQL service not available, proceeding without detailed commit changes")
+                          commits
+                        end
+
+      analysis_result = @gemini_service.analyze_activity(
+        username: username,
+        commits_with_code: commits_with_code,
+        review_count: review_count,
+        time_window_days: time_window_days
+      )
+      @logger.debug("Gemini analysis result for #{username}: #{analysis_result}")
+
+      # Add username and timestamp to the result for context
+      analysis_result[:username] = username
+      analysis_result[:analysis_timestamp] = Time.now.iso8601
+
+      # Calculate language distribution
+      
+      analysis_result[:language_distribution] = LanguageAnalyzer.calculate_distribution(commits_with_code.map{ |f| f[:code_changes][:files] }.flatten)
+
+      if analysis_result[:error]
+         @logger.error("Analysis failed for #{username}: #{analysis_result[:error]}")
+      else
+         @logger.info("Analysis successful for #{username}")
+      end
+
+      analysis_result
+    end
+  end
+end

data/lib/configuration.rb

@@ -0,0 +1,260 @@
+# github_daily_digest/lib/configuration.rb
+require 'dotenv'
+require 'active_support/all' # For parsing duration string
+require 'optparse'
+
+module GithubDailyDigest
+  class Configuration
+    attr_reader :github_token, :gemini_api_key, :github_org_name, :github_org_names,
+                :log_level, :fetch_window_duration, :max_api_retries,
+                :rate_limit_sleep_base, :time_since, :gemini_model,
+                :json_only, :output_to_stdout, :help_requested,
+                :output_formats, :output_destination, :concise_output,
+                :use_graphql, :no_graphql, :specific_users,
+                :html_theme, :html_title, :html_show_charts,
+                :time_window_days
+
+    def initialize(args = nil)
+      Dotenv.load
+      @json_only = true # Default to JSON only output
+      @output_to_stdout = true # Default to stdout
+      @gemini_model = ENV.fetch('GEMINI_MODEL', 'gemini-1.5-flash')
+      @help_requested = false
+      
+      # Support multiple output formats - if env specifies a single format, convert to array
+      output_format_env = ENV.fetch('OUTPUT_FORMAT', 'json').downcase
+      @output_formats = output_format_env.include?(',') ? 
+                      output_format_env.split(',').map(&:strip).map(&:downcase) : 
+                      [output_format_env.downcase]
+      
+      @output_destination = ENV.fetch('OUTPUT_DESTINATION', 'stdout').downcase # 'stdout' or 'log'
+      @concise_output = ENV.fetch('CONCISE_OUTPUT', 'true').downcase == 'true' # Whether to use concise output format (defaults to true)
+      @use_graphql = ENV.fetch('USE_GRAPHQL', 'true').downcase == 'true' # Whether to use GraphQL API (defaults to true)
+      @no_graphql = !@use_graphql # Inverse of use_graphql for easier API
+      @specific_users = ENV.fetch('SPECIFIC_USERS', '').split(',').map(&:strip).reject(&:empty?) # Specific users to process
+      
+      # HTML-specific options
+      @html_theme = ENV.fetch('HTML_THEME', 'default').downcase # 'default', 'dark', or 'light'
+      @html_title = ENV.fetch('HTML_TITLE', nil) # Custom title for HTML output
+      @html_show_charts = ENV.fetch('HTML_SHOW_CHARTS', 'true').downcase == 'true' # Whether to show charts in HTML output
+
+      # Parse command line arguments if provided
+      parse_command_line_args(args) if args
+
+      # Early return if help is requested
+      return if @help_requested
+
+      # Load environment variables
+      load_env_vars
+
+      # Validate the configuration
+      validate_config
+
+      # Calculate the time window
+      calculate_time_window
+    end
+
+    def help_text
+      <<~HELP
+        USAGE: github-daily-digest [options]
+
+        GitHub Daily Digest generates insights about developer activity using GitHub API and Google's Gemini AI.
+
+        Options:
+          -h, --help                       Show this help message
+          -t, --token TOKEN                GitHub API token (instead of GITHUB_TOKEN env var)
+          -g, --gemini-key KEY             Gemini API key (instead of GEMINI_API_KEY env var)
+          -o, --org NAME                   GitHub organization name(s) (instead of GITHUB_ORG_NAME env var)
+                                           Multiple organizations can be comma-separated (e.g., 'org1,org2,org3')
+          -u, --users USERNAMES            Specific users to process (comma-separated, e.g. 'user1,user2,user3')
+                                           If not specified, all organization members will be processed
+          -m, --model MODEL                Gemini model to use (default: gemini-1.5-flash)
+          -w, --window DURATION            Time window for fetching data (e.g., '1.day', '12.hours')
+          -v, --verbose                    Enable verbose output (instead of JSON-only)
+          -l, --log-level LEVEL            Set log level (DEBUG, INFO, WARN, ERROR, FATAL)
+          -f, --format FORMAT              Output format: json, markdown, html (default: json)
+                                           html option generates a standalone web page with charts
+          -d, --destination DEST           Output destination: stdout or log (default: stdout)
+          -c, --[no-]concise               Use concise output format (overview + combined only, default: true)
+          -q, --[no-]graphql               Use GraphQL API for better performance and data quality (default: true)
+                                           Use --no-graphql to fall back to REST API
+          
+          HTML Output Options:
+          --html-theme THEME               Theme for HTML output: default, dark, light (default: default)
+          --html-title TITLE               Custom title for HTML output
+          --[no-]html-charts               Include interactive charts in HTML output (default: true)
+
+        Examples:
+          github-daily-digest --token YOUR_TOKEN --gemini-key YOUR_KEY --org acme-inc
+          github-daily-digest --window 2.days --verbose
+          github-daily-digest --format markdown --destination log
+          github-daily-digest --org "org1,org2,org3" --format markdown
+
+        Environment variables can also be used instead of command-line options:
+          GITHUB_TOKEN, GEMINI_API_KEY, GITHUB_ORG_NAME, GEMINI_MODEL, FETCH_WINDOW, LOG_LEVEL,
+          OUTPUT_FORMAT, OUTPUT_DESTINATION, CONCISE_OUTPUT, USE_GRAPHQL
+      HELP
+    end
+
+    # Check if we need to show help
+    def help_requested?
+      @help_requested
+    end
+    
+    # Returns number of days in the configured time window
+    def time_window_days
+      if @fetch_window_duration
+        # Handle ActiveSupport::Duration objects
+        if @fetch_window_duration.respond_to?(:in_days)
+          return @fetch_window_duration.in_days.to_i
+        # Handle string durations like '7.days'
+        elsif @fetch_window_duration.is_a?(String)
+          match = @fetch_window_duration.match(/(\d+)\.days/)
+          return match ? match[1].to_i : 7
+        end
+      end
+      
+      # Default to 7 days if fetch_window_duration not set or has unexpected type
+      return 7
+    end
+
+    private
+
+    def parse_command_line_args(args)
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: github-daily-digest [options]"
+
+        opts.on("-h", "--help", "Show help") do
+          puts help_text
+          @help_requested = true
+        end
+
+        opts.on("-t", "--token TOKEN", "GitHub API token") do |token|
+          ENV['GITHUB_TOKEN'] = token
+        end
+
+        opts.on("-g", "--gemini-key KEY", "Gemini API key") do |key|
+          ENV['GEMINI_API_KEY'] = key
+        end
+
+        opts.on("-o", "--org NAME", "GitHub organization name(s)") do |org|
+          ENV['GITHUB_ORG_NAME'] = org
+        end
+
+        opts.on("-u", "--users USERNAMES", "Specific users to process (comma-separated)") do |users|
+          @specific_users = users.split(',').map(&:strip).reject(&:empty?)
+        end
+
+        opts.on("-m", "--model MODEL", "Gemini model to use") do |model|
+          @gemini_model = model
+        end
+
+        opts.on("-w", "--window DURATION", "Time window for fetching data (e.g., '1.day')") do |window|
+          ENV['FETCH_WINDOW'] = window
+        end
+
+        opts.on("-v", "--verbose", "Enable verbose output (instead of JSON-only)") do
+          @json_only = false
+        end
+
+        opts.on("-l", "--log-level LEVEL", "Set log level (DEBUG, INFO, WARN, ERROR, FATAL)") do |level|
+          ENV['LOG_LEVEL'] = level
+        end
+
+        opts.on("-f", "--format FORMAT", "Output format (json, markdown, html)") do |format|
+          @output_formats = format.downcase.split(',').map(&:strip).map(&:downcase)
+          unless @output_formats.all? { |f| ['json', 'markdown', 'html'].include?(f) }
+            puts "Error: Invalid output format(s) '#{format}'. Must be one or more of 'json', 'markdown', or 'html'."
+            exit(1)
+          end
+        end
+
+        opts.on("-d", "--destination DEST", "Output destination (stdout, log)") do |dest|
+          @output_destination = dest.downcase
+          unless ['stdout', 'log'].include?(@output_destination)
+            puts "Error: Invalid output destination '#{dest}'. Must be 'stdout' or 'log'."
+            exit(1)
+          end
+          @output_to_stdout = (@output_destination == 'stdout')
+        end
+
+        opts.on("-c", "--[no-]concise", "Use concise output format (overview + combined only)") do |concise|
+          @concise_output = concise
+        end
+
+        opts.on("-q", "--[no-]graphql", "Use GraphQL API for better performance and data quality") do |graphql|
+          @use_graphql = graphql
+          @no_graphql = !graphql
+        end
+        
+        # HTML-specific options
+        opts.on("--html-theme THEME", "Theme for HTML output (default, dark, light)") do |theme|
+          unless ['default', 'dark', 'light'].include?(theme.downcase)
+            puts "Error: Invalid HTML theme '#{theme}'. Must be 'default', 'dark', or 'light'."
+            exit(1)
+          end
+          @html_theme = theme.downcase
+        end
+        
+        opts.on("--html-title TITLE", "Custom title for HTML output") do |title|
+          @html_title = title
+        end
+        
+        opts.on("--[no-]html-charts", "Include interactive charts in HTML output") do |show_charts|
+          @html_show_charts = show_charts
+        end
+      end
+
+      begin
+        parser.parse!(args)
+      rescue OptionParser::InvalidOption, OptionParser::MissingArgument => e
+        puts "Error: #{e.message}"
+        puts parser
+        exit(1)
+      end
+    end
+
+    def load_env_vars
+      @github_token = ENV['GITHUB_TOKEN']
+      @gemini_api_key = ENV['GEMINI_API_KEY']
+      @github_org_name = ENV['GITHUB_ORG_NAME']
+      # Parse multiple organizations if provided (comma-separated)
+      @github_org_names = @github_org_name.split(',').map(&:strip) if @github_org_name
+      @log_level = ENV.fetch('LOG_LEVEL', 'INFO').upcase
+      @fetch_window_duration_str = ENV.fetch('FETCH_WINDOW', '7.days')
+      @max_api_retries = ENV.fetch('MAX_API_RETRIES', '3').to_i
+      @rate_limit_sleep_base = ENV.fetch('RATE_LIMIT_SLEEP_BASE', '5').to_i
+    end
+
+    def validate_config
+      return if @help_requested
+
+      raise ArgumentError, "Missing required env var or option: GITHUB_TOKEN" unless @github_token
+      raise ArgumentError, "Missing required env var or option: GEMINI_API_KEY" unless @gemini_api_key
+      raise ArgumentError, "Missing required env var or option: GITHUB_ORG_NAME" unless @github_org_name
+      validate_log_level
+      parse_fetch_window
+    end
+
+    def validate_log_level
+      valid_levels = %w[DEBUG INFO WARN ERROR FATAL]
+      unless valid_levels.include?(@log_level)
+        raise ArgumentError, "Invalid LOG_LEVEL: #{@log_level}. Must be one of #{valid_levels.join(', ')}"
+      end
+    end
+
+    def parse_fetch_window
+      # Attempt to parse the duration string (e.g., "1.day", "24.hours")
+      @fetch_window_duration = eval(@fetch_window_duration_str) # Use eval carefully here
+      unless @fetch_window_duration.is_a?(ActiveSupport::Duration)
+         raise ArgumentError, "Invalid FETCH_WINDOW format: '#{@fetch_window_duration_str}'. Use ActiveSupport format (e.g., '1.day', '24.hours')."
+      end
+    rescue SyntaxError, NameError => e
+        raise ArgumentError, "Error parsing FETCH_WINDOW: '#{@fetch_window_duration_str}'. #{e.message}"
+    end
+
+    def calculate_time_window
+      @time_since = (@fetch_window_duration.ago).iso8601
+    end
+  end
+end