aireview 0.1.0

data/lib/aireview/reviewer.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+require_relative 'errors'
+require_relative 'output_schemas'
+require_relative 'utils'
+require 'timeout'
+
+module Aireview
+  class Reviewer
+    MAX_TRANSIENT_RETRIES = 2
+    TRANSIENT_RETRY_BASE_DELAY = 2.0
+    TRANSIENT_RETRY_JITTER_RANGE = 2.0..5.0
+    PROVIDER_RETRY_DELAY_MULTIPLIER_RANGE = 2.0..2.4
+    OVERLOADED_RETRY_DELAY_RANGE = 90.0..150.0
+    RETRY_WAIT_LOG_FORMAT = 'LLM %<stage>s request will sleep %<delay>.1fs before retry%<source>s ' \
+                            '(attempt %<next_attempt>d/%<max_attempts>d, model=%<model>s)'
+
+    def initialize(config:, logger: Logger.new($stderr))
+      @config = config
+      @logger = logger
+      @llm_contexts = {}
+    end
+
+    def generate(system_prompt:, user_prompt:)
+      call_llm(
+        stage: 'generate',
+        system: system_prompt,
+        user: user_prompt,
+        options: {
+          model: @config.generate_model,
+          temperature: @config.generate_temperature,
+          provider: @config.generate_provider,
+          schema: GenerateOutputSchema
+        }
+      )
+    end
+
+    def critique(system_prompt:, user_prompt:)
+      call_llm(
+        stage: 'critique',
+        system: system_prompt,
+        user: user_prompt,
+        options: {
+          model: @config.critique_model,
+          temperature: @config.critique_temperature,
+          provider: @config.critique_provider,
+          schema: CritiqueOutputSchema
+        }
+      )
+    end
+
+    private
+
+    def call_llm(stage:, system:, user:, options:)
+      require 'ruby_llm'
+
+      @config.require_llm_configuration!
+      context = llm_context(stage, options[:provider])
+      response = request_with_retries(stage: stage, model: options[:model]) do
+        perform_llm_request(
+          context: context,
+          stage: stage,
+          system: system,
+          user: user,
+          options: options
+        )
+      end
+      response.content
+    rescue LoadError => e
+      @logger.error("LLM #{stage} setup failed: #{e.message}")
+      raise ConfigError, "Missing dependency: #{e.message}"
+    rescue Timeout::Error
+      @logger.warn(
+        "LLM #{stage} request timed out after #{@config.llm_timeout} seconds (model=#{options[:model]})"
+      )
+      raise ApiError, "LLM request timed out after #{@config.llm_timeout} seconds. " \
+                      "Try again later or switch model via --generate-model/--critique-model."
+    end
+
+    def perform_llm_request(context:, stage:, system:, user:, options:)
+      model = options[:model]
+      temperature = options[:temperature]
+      @logger.info("LLM #{stage} request started (model=#{model}, temperature=#{temperature})")
+      chat = build_chat(context: context, stage: stage, model: model, provider: options[:provider])
+      chat = configure_reasoning(chat: chat, model: model, provider: options[:provider])
+        .with_temperature(temperature.to_f)
+        .with_schema(options[:schema])
+      chat.with_instructions(system)
+      response = Timeout.timeout(@config.llm_timeout.to_f) { chat.ask(user) }
+      @logger.info("LLM #{stage} request completed (model=#{model})")
+      response
+    end
+
+    def configure_reasoning(chat:, model:, provider:)
+      return chat unless provider == 'ollama' && model.start_with?('gpt-oss:')
+
+      chat.with_thinking(effort: :low)
+    end
+
+    def build_chat(context:, stage:, model:, provider:)
+      context.chat(model: model, provider: provider.to_sym)
+    rescue RubyLLM::ModelNotFoundError
+      @logger.warn(
+        "LLM #{stage}: model not found in RubyLLM registry; " \
+        "using fallback with incomplete model metadata " \
+        "(model=#{model}, provider=#{provider})"
+      )
+      context.chat(model: model, provider: provider.to_sym, assume_model_exists: true)
+    end
+
+    def request_with_retries(stage:, model:)
+      attempt = 0
+
+      begin
+        attempt += 1
+        yield
+      rescue StandardError => e
+        raise unless ruby_llm_api_error?(e)
+
+        @logger.warn("LLM #{stage} request failed (model=#{model}): #{e.class}: #{e.message}")
+        raise ApiError, llm_error_message(e) unless retry_llm_request?(e, attempt)
+
+        wait_before_retry(error: e, attempt: attempt, stage: stage, model: model)
+        retry
+      end
+    end
+
+    def retry_llm_request?(error, attempt)
+      transient_llm_error?(error) && attempt <= MAX_TRANSIENT_RETRIES
+    end
+
+    def wait_before_retry(error:, attempt:, stage:, model:)
+      retry_delay = transient_retry_delay(error: error, attempt: attempt)
+      @logger.warn(
+        format(
+          RETRY_WAIT_LOG_FORMAT,
+          stage: stage,
+          delay: retry_delay[:delay],
+          source: retry_delay_source(retry_delay),
+          next_attempt: attempt + 1,
+          max_attempts: MAX_TRANSIENT_RETRIES + 1,
+          model: model
+        )
+      )
+      sleep_started_at = monotonic_time
+      sleep(retry_delay[:delay])
+      log_retry_wait_completed(stage, model, monotonic_time - sleep_started_at)
+    end
+
+    def log_retry_wait_completed(stage, model, waited)
+      @logger.info(
+        format(
+          'LLM %<stage>s retry wait completed after %<waited>.1fs (model=%<model>s)',
+          stage: stage,
+          waited: waited,
+          model: model
+        )
+      )
+    end
+
+    def ruby_llm_api_error?(error)
+      defined?(RubyLLM::Error) && error.is_a?(RubyLLM::Error)
+    end
+
+    def transient_llm_error?(error)
+      error.is_a?(RubyLLM::RateLimitError) ||
+        error.is_a?(RubyLLM::ServiceUnavailableError) ||
+        error.is_a?(RubyLLM::OverloadedError)
+    end
+
+    def monotonic_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def transient_retry_delay(error:, attempt:)
+      provider_delay = retry_after_seconds(error.message)
+      if provider_delay
+        multiplier = rand(PROVIDER_RETRY_DELAY_MULTIPLIER_RANGE)
+        return {
+          delay: provider_delay * multiplier,
+          provider_delay: provider_delay,
+          multiplier: multiplier,
+          strategy: :provider_hint
+        }
+      end
+
+      if overloaded_llm_error?(error)
+        return {
+          delay: rand(OVERLOADED_RETRY_DELAY_RANGE),
+          provider_delay: nil,
+          multiplier: nil,
+          strategy: :overloaded
+        }
+      end
+
+      base_delay = TRANSIENT_RETRY_BASE_DELAY * (2**(attempt - 1))
+      {
+        delay: base_delay + rand(TRANSIENT_RETRY_JITTER_RANGE),
+        provider_delay: nil,
+        multiplier: nil,
+        strategy: :fallback
+      }
+    end
+
+    def retry_delay_source(retry_delay)
+      return ' (overloaded backoff)' if retry_delay[:strategy] == :overloaded
+      return '' unless retry_delay[:provider_delay]
+
+      format(
+        ' (provider retry hint %<provider_delay>.1fs, multiplier %<multiplier>.2fx)',
+        provider_delay: retry_delay[:provider_delay],
+        multiplier: retry_delay[:multiplier]
+      )
+    end
+
+    def overloaded_llm_error?(error)
+      error.is_a?(RubyLLM::ServiceUnavailableError) ||
+        error.is_a?(RubyLLM::OverloadedError)
+    end
+
+    def retry_after_seconds(message)
+      match = message.to_s.match(/retry\s+(?:in|after)\s+(\d+(?:\.\d+)?)\s*(?:s|sec|secs|second|seconds)\b/i)
+      match[1].to_f if match
+    end
+
+    def llm_error_message(error)
+      case error
+      when RubyLLM::ServiceUnavailableError, RubyLLM::OverloadedError
+        "LLM service is temporarily unavailable or overloaded: #{error.message}. " \
+        "Try again later or switch model via --generate-model/--critique-model."
+      when RubyLLM::RateLimitError
+        "LLM rate limit exceeded: #{error.message}. " \
+        "Try again later or switch model via --generate-model/--critique-model."
+      when RubyLLM::ContextLengthExceededError
+        "LLM context limit exceeded: #{error.message}. Try reducing the MR diff or ignore more paths."
+      else
+        "LLM API request failed: #{error.message}"
+      end
+    end
+
+    def llm_context(stage, provider)
+      @llm_contexts[stage] ||= build_llm_context(provider.to_s)
+    end
+
+    def build_llm_context(provider)
+      api_key = @config.provider_api_key(provider) unless provider == 'ollama'
+
+      RubyLLM.context do |ruby_config|
+        configure_http_proxy(ruby_config)
+        ruby_config.request_timeout = @config.llm_timeout.to_f
+        configure_provider(ruby_config, provider, api_key)
+      end
+    end
+
+    def configure_http_proxy(ruby_config)
+      return unless Aireview::Utils.present?(@config.llm_http_proxy)
+
+      ruby_config.http_proxy = @config.llm_http_proxy
+    end
+
+    def configure_provider(ruby_config, provider, api_key)
+      case provider
+      when 'gemini', 'openai', 'openrouter'
+        configure_remote_provider(ruby_config, provider, api_key)
+      when 'anthropic'
+        ruby_config.anthropic_api_key = api_key
+      when 'ollama'
+        ruby_config.ollama_api_base = @config.ollama_api_base
+      else
+        raise ConfigError, "Unsupported LLM provider: #{provider.inspect}"
+      end
+    end
+
+    def configure_remote_provider(ruby_config, provider, api_key)
+      ruby_config.public_send("#{provider}_api_key=", api_key)
+      return unless Aireview::Utils.present?(@config.llm_api_base)
+
+      ruby_config.public_send("#{provider}_api_base=", @config.llm_api_base)
+    end
+  end
+end

data/lib/aireview/secret_scrubber.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+require_relative 'utils'
+
+module Aireview
+  class SecretScrubber
+    REDACTED = '[REDACTED]'
+
+    BUILTIN_RULES = [
+      [/-----BEGIN [A-Z ]*PRIVATE KEY-----.*?-----END [A-Z ]*PRIVATE KEY-----/m, REDACTED],
+      [/\bAKIA[0-9A-Z]{16}\b/, REDACTED],
+      [/\bsk-(?:proj-|ant-)?[A-Za-z0-9_-]{20,}\b/, REDACTED],
+      [/\b(?:gh[ps]|glpat)_[A-Za-z0-9_-]{20,}\b/, REDACTED],
+      [/(Authorization:\s*Bearer\s+)[A-Za-z0-9._-]+/i, '\1[REDACTED]'],
+      [/(Bearer\s+)[A-Za-z0-9._-]{20,}/i, '\1[REDACTED]'],
+      [/(\baws_secret_access_key\b\s*[:=]\s*["']?)[A-Za-z0-9\/+=]{20,}(["']?)/i, '\1[REDACTED]\2'],
+      [/(\b(?:api[_-]?key|token|secret|password|passwd|client_secret)\w*\s*[:=]\s*["']?)[^"'\s]+(["']?)/i,
+       '\1[REDACTED]\2'],
+      [/(x-api-key:\s*)[A-Za-z0-9._-]+/i, '\1[REDACTED]']
+    ].freeze
+
+    def initialize(secret_patterns:, secret_files:, logger: Logger.new($stderr))
+      @logger = logger
+      @secret_files = Array(secret_files).compact
+      @custom_rules = compile_patterns(secret_patterns)
+    end
+
+    def scrub_changes(changes)
+      Array(changes).map { |change| scrub_change(change) }
+    end
+
+    def scrub_change(change)
+      path = change['new_path'] || change['old_path']
+      scrubbed = change.dup
+
+      scrubbed['diff'] =
+        if secret_file?(path)
+          "[REDACTED: secret file #{path}]"
+        else
+          scrub_text(change['diff'].to_s)
+        end
+
+      scrubbed
+    end
+
+    def scrub_text(text)
+      (BUILTIN_RULES + @custom_rules).reduce(text.to_s) do |memo, (pattern, replacement)|
+        memo.gsub(pattern, replacement)
+      end
+    end
+
+    private
+
+    def compile_patterns(patterns)
+      Array(patterns).compact.filter_map do |pattern|
+        [Regexp.new(pattern, Regexp::IGNORECASE), REDACTED]
+      rescue RegexpError => e
+        @logger.warn("Skipping invalid secret pattern #{pattern.inspect}: #{e.message}")
+        nil
+      end
+    end
+
+    def secret_file?(path)
+      return false if Aireview::Utils.blank?(path)
+
+      @secret_files.any? do |pattern|
+        File.fnmatch?(pattern, path, File::FNM_DOTMATCH | File::FNM_EXTGLOB)
+      end
+    end
+  end
+end

data/lib/aireview/utils.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module Aireview
+  module Utils
+    module_function
+
+    def blank?(value)
+      value.nil? || value.to_s.strip.empty?
+    end
+
+    def present?(value)
+      !blank?(value)
+    end
+
+    def presence(value)
+      present?(value) ? value.to_s.strip : nil
+    end
+  end
+end

data/lib/aireview/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module Aireview
+  VERSION = '0.1.0'
+end

data/lib/aireview.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+require 'json'
+require 'logger'
+require 'optparse'
+require 'pathname'
+require 'uri'
+require 'yaml'
+
+require_relative 'aireview/version'
+require_relative 'aireview/errors'
+require_relative 'aireview/utils'
+require_relative 'aireview/config'
+require_relative 'aireview/mr_parser'
+require_relative 'aireview/diff_fetcher'
+require_relative 'aireview/secret_scrubber'
+require_relative 'aireview/context_builder'
+require_relative 'aireview/reviewer'
+require_relative 'aireview/review_pipeline'
+require_relative 'aireview/gitlab_client'
+require_relative 'aireview/jira_client'
+require_relative 'aireview/review_marker'
+require_relative 'aireview/publisher'
+require_relative 'aireview/cli'

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: aireview
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Denis Levenko
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-09-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: ruby_llm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.16.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.16.0
+description: 'Reviews self-hosted GitLab merge requests with a two-pass LLM pipeline:
+  the first pass finds candidate findings, the second one critiques them and drops
+  the weak ones. Supports Gemini and local Ollama, optional Jira context and posting
+  a single updatable review note back to the merge request.'
+email:
+executables:
+- aireview
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- bin/aireview
+- config/.aireview.yml.example
+- lib/aireview.rb
+- lib/aireview/cli.rb
+- lib/aireview/config.rb
+- lib/aireview/context_builder.rb
+- lib/aireview/diff_fetcher.rb
+- lib/aireview/errors.rb
+- lib/aireview/gitlab_client.rb
+- lib/aireview/jira_client.rb
+- lib/aireview/mr_parser.rb
+- lib/aireview/output_schemas.rb
+- lib/aireview/prompts/critique.txt
+- lib/aireview/prompts/generate.txt
+- lib/aireview/publisher.rb
+- lib/aireview/review_marker.rb
+- lib/aireview/review_pipeline.rb
+- lib/aireview/review_renderer.rb
+- lib/aireview/review_schemas.rb
+- lib/aireview/reviewer.rb
+- lib/aireview/secret_scrubber.rb
+- lib/aireview/utils.rb
+- lib/aireview/version.rb
+homepage: https://github.com/DenisDenis9331/aireview
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/DenisDenis9331/aireview
+  source_code_uri: https://github.com/DenisDenis9331/aireview
+  changelog_uri: https://github.com/DenisDenis9331/aireview/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/DenisDenis9331/aireview/issues
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: Local GitLab merge request review CLI powered by LLMs
+test_files: []