aireview 0.1.0

data/lib/aireview/config.rb

@@ -0,0 +1,356 @@
+# frozen_string_literal: true
+require 'logger'
+require 'pathname'
+require 'yaml'
+require_relative 'errors'
+require_relative 'utils'
+
+module Aireview
+  class Config
+    DEFAULT_SECRET_FILES = [
+      '.env',
+      '.env.*',
+      'config/secrets.yml',
+      'config/credentials/*.key',
+      'spec/fixtures/cassettes/*.yml',
+      'spec/fixtures/cassettes/**/*.yml',
+      'spec/cassettes/*.yml',
+      'spec/cassettes/**/*.yml',
+      'test/fixtures/cassettes/*.yml',
+      'test/fixtures/cassettes/**/*.yml'
+    ].freeze
+
+    REVIEW_MODES = %w[update once].freeze
+
+    DEFAULTS = {
+      'review_language' => 'en',
+      'review_mode' => 'update',
+      'ignore_paths' => [],
+      'secret_patterns' => [],
+      'secret_files' => DEFAULT_SECRET_FILES,
+      'review_instructions' => nil,
+      'llm_api_base' => nil,
+      'ollama_api_base' => 'http://localhost:11434/v1',
+      'llm_http_proxy' => nil,
+      'llm' => {
+        'provider' => 'gemini',
+        'temperature' => 0,
+        'timeout' => 60
+      }
+    }.freeze
+
+    ENV_MAPPING = {
+      'gitlab_url' => 'GITLAB_URL',
+      'gitlab_token' => 'GITLAB_TOKEN',
+      'jira_url' => 'JIRA_URL',
+      'jira_login' => 'JIRA_LOGIN',
+      'jira_password' => 'JIRA_PASSWORD',
+      'review_language' => 'REVIEW_LANGUAGE',
+      'review_mode' => 'REVIEW_MODE',
+      'llm_api_base' => 'LLM_API_BASE',
+      'ollama_api_base' => 'OLLAMA_API_BASE',
+      'llm_http_proxy' => 'LLM_HTTP_PROXY'
+    }.freeze
+
+    PROVIDER_KEY_MAPPING = {
+      'gemini' => 'GEMINI_API_KEY',
+      'ollama' => nil
+    }.freeze
+
+    attr_reader :config_path
+
+    def self.load(config_path: nil, cwd: Dir.pwd, env: ENV, logger: Logger.new($stderr))
+      load_dotenv(cwd)
+
+      file_path = config_path ? File.expand_path(config_path, cwd) : discover_file(cwd, '.aireview.yml')
+      file_config = File.file?(file_path) ? normalize_hash(YAML.load_file(file_path) || {}) : {}
+
+      merged = deep_merge(DEFAULTS, file_config)
+      merged = deep_merge(merged, env_config(env))
+
+      new(merged, config_path: File.file?(file_path) ? file_path : nil, logger: logger)
+    end
+
+    def self.load_dotenv(cwd)
+      require 'dotenv'
+      dotenv_path = discover_file(cwd, '.env')
+      Dotenv.load(dotenv_path) if File.file?(dotenv_path)
+    rescue LoadError
+      nil
+    end
+
+    def self.discover_file(cwd, basename)
+      current = Pathname.new(cwd).expand_path
+
+      loop do
+        candidate = current.join(basename)
+        return candidate.to_s if candidate.file?
+
+        break if current.root?
+
+        current = current.parent
+      end
+
+      File.join(cwd, basename)
+    end
+
+    def self.env_config(env)
+      mapped_env_config(env)
+        .merge('llm' => llm_env_config(env))
+        .merge(provider_key_env_config(env))
+        .merge(generic_api_key_env_config(env))
+    end
+
+    def self.mapped_env_config(env)
+      ENV_MAPPING.each_with_object({}) do |(key, env_key), config|
+        value = env[env_key]
+        config[key] = value unless Aireview::Utils.blank?(value)
+      end
+    end
+
+    def self.llm_env_config(env)
+      {
+        'provider' => env['LLM_PROVIDER'],
+        'temperature' => parse_float(env['LLM_TEMPERATURE']),
+        'timeout' => parse_float(env['LLM_TIMEOUT']),
+        'generate' => llm_stage_env_config(env, 'GENERATE'),
+        'critique' => llm_stage_env_config(env, 'CRITIQUE')
+      }.compact.reject { |key, value| %w[generate critique].include?(key) && value.empty? }
+    end
+
+    def self.llm_stage_env_config(env, stage)
+      {
+        'provider' => env["LLM_#{stage}_PROVIDER"],
+        'model' => env["LLM_#{stage}_MODEL"],
+        'temperature' => parse_float(env["LLM_#{stage}_TEMPERATURE"])
+      }.compact
+    end
+
+    def self.provider_key_env_config(env)
+      PROVIDER_KEY_MAPPING.each_with_object({}) do |(provider, env_key), config|
+        next unless env_key
+
+        value = env[env_key]
+        config["#{provider}_api_key"] = value unless Aireview::Utils.blank?(value)
+      end
+    end
+
+    def self.generic_api_key_env_config(env)
+      api_key = env['LLM_API_KEY']
+      return {} if Aireview::Utils.blank?(api_key)
+
+      {'llm_api_key' => api_key}
+    end
+
+    def self.parse_float(value)
+      return nil if Aireview::Utils.blank?(value)
+
+      Float(value)
+    rescue ArgumentError
+      nil
+    end
+
+    def self.deep_merge(left, right)
+      left.merge(right) do |_, old_value, new_value|
+        if old_value.is_a?(Hash) && new_value.is_a?(Hash)
+          deep_merge(old_value, new_value)
+        else
+          new_value
+        end
+      end
+    end
+
+    def self.normalize_hash(value)
+      case value
+      when Hash
+        value.each_with_object({}) do |(key, inner_value), result|
+          result[key.to_s] = normalize_hash(inner_value)
+        end
+      when Array
+        value.map { |item| normalize_hash(item) }
+      else
+        value
+      end
+    end
+
+    def initialize(data, config_path:, logger:)
+      @data = self.class.normalize_hash(data)
+      @config_path = config_path
+      @logger = logger
+    end
+
+    def with_overrides(
+      generate_model: nil,
+      critique_model: nil,
+      generate_temperature: nil,
+      critique_temperature: nil
+    )
+      llm_config = {
+        'generate' => stage_overrides(model: generate_model, temperature: generate_temperature),
+        'critique' => stage_overrides(model: critique_model, temperature: critique_temperature)
+      }.reject { |_, overrides| overrides.empty? }
+      return self if llm_config.empty?
+
+      merged = self.class.deep_merge(
+        @data,
+        'llm' => llm_config
+      )
+      self.class.new(merged, config_path: config_path, logger: @logger)
+    end
+
+    def gitlab_url
+      @data['gitlab_url']
+    end
+
+    def gitlab_token
+      @data['gitlab_token']
+    end
+
+    def jira_url
+      @data['jira_url']
+    end
+
+    def jira_login
+      @data['jira_login']
+    end
+
+    def jira_password
+      @data['jira_password']
+    end
+
+    def llm_provider
+      dig('llm', 'provider') || DEFAULTS.dig('llm', 'provider')
+    end
+
+    def llm_temperature
+      dig('llm', 'temperature') || DEFAULTS.dig('llm', 'temperature')
+    end
+
+    def llm_timeout
+      dig('llm', 'timeout') || DEFAULTS.dig('llm', 'timeout')
+    end
+
+    def generate_model
+      dig('llm', 'generate', 'model')
+    end
+
+    def critique_model
+      dig('llm', 'critique', 'model')
+    end
+
+    def generate_provider
+      dig('llm', 'generate', 'provider') || llm_provider
+    end
+
+    def critique_provider
+      dig('llm', 'critique', 'provider') || llm_provider
+    end
+
+    def generate_temperature
+      dig('llm', 'generate', 'temperature') || llm_temperature
+    end
+
+    def critique_temperature
+      dig('llm', 'critique', 'temperature') || llm_temperature
+    end
+
+    def llm_api_base
+      @data['llm_api_base']
+    end
+
+    def ollama_api_base
+      @data['ollama_api_base'] || DEFAULTS['ollama_api_base']
+    end
+
+    def llm_http_proxy
+      @data['llm_http_proxy'] || dig('llm', 'http_proxy')
+    end
+
+    def review_language
+      @data['review_language'] || DEFAULTS['review_language']
+    end
+
+    # update — обновляем свою заметку, когда дифф или настройки изменились,
+    # once — ревьюим один раз автоматически; Retry джоба обновляет ревью при изменениях.
+    def review_mode
+      mode = (@data['review_mode'] || DEFAULTS['review_mode']).to_s
+      return mode if REVIEW_MODES.include?(mode)
+
+      @logger.warn("Unknown review_mode #{mode.inspect}, using #{DEFAULTS['review_mode']}")
+      DEFAULTS['review_mode']
+    end
+
+    def ignore_paths
+      Array(@data['ignore_paths']).compact
+    end
+
+    def secret_patterns
+      Array(@data['secret_patterns']).compact
+    end
+
+    def secret_files
+      (DEFAULT_SECRET_FILES + Array(@data['secret_files']).compact).uniq
+    end
+
+    def review_instructions
+      @data['review_instructions']
+    end
+
+    def llm_api_key
+      @data['llm_api_key']
+    end
+
+    def provider_api_key(provider = llm_provider)
+      @data["#{provider}_api_key"] || llm_api_key
+    end
+
+    def jira_configured?
+      Aireview::Utils.present?(jira_url) &&
+        Aireview::Utils.present?(jira_login) &&
+        Aireview::Utils.present?(jira_password)
+    end
+
+    def require_gitlab_token!
+      return gitlab_token if Aireview::Utils.present?(gitlab_token)
+
+      raise ConfigError, 'GITLAB_TOKEN is required'
+    end
+
+    def require_models!
+      missing = []
+      missing << 'llm.generate.model (or LLM_GENERATE_MODEL)' if Aireview::Utils.blank?(generate_model)
+      missing << 'llm.critique.model (or LLM_CRITIQUE_MODEL)' if Aireview::Utils.blank?(critique_model)
+      raise ConfigError, "LLM models are required: #{missing.join(', ')}" unless missing.empty?
+    end
+
+    def require_llm_configuration!
+      require_models!
+
+      missing_keys = {
+        'generate' => generate_provider,
+        'critique' => critique_provider
+      }.filter_map do |stage, provider|
+        next if provider.to_s == 'ollama'
+        next if Aireview::Utils.present?(provider_api_key(provider))
+
+        "#{stage}: API key is required for provider #{provider.inspect}"
+      end
+      raise ConfigError, missing_keys.join(', ') unless missing_keys.empty?
+    end
+
+    private
+
+    def stage_overrides(model:, temperature:)
+      {
+        'model' => model,
+        'temperature' => temperature
+      }.compact
+    end
+
+    def dig(*keys)
+      keys.reduce(@data) do |accumulator, key|
+        accumulator.is_a?(Hash) ? accumulator[key] : nil
+      end
+    end
+  end
+end

data/lib/aireview/context_builder.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+require_relative 'utils'
+require_relative 'secret_scrubber'
+
+module Aireview
+  class ContextBuilder
+    MAX_DIFF_CHARS = 120_000
+    GENERATE_PROMPT_TEMPLATE = File.read(File.expand_path('prompts/generate.txt', __dir__)).strip.freeze
+    CRITIQUE_PROMPT_TEMPLATE = File.read(File.expand_path('prompts/critique.txt', __dir__)).strip.freeze
+    LANGUAGE_NAMES = {
+      'ru' => 'Russian',
+      'en' => 'English'
+    }.freeze
+
+    def initialize(config:, logger: Logger.new($stderr))
+      @config = config
+      @logger = logger
+      @secret_scrubber = SecretScrubber.new(
+        secret_patterns: config.secret_patterns,
+        secret_files: config.secret_files,
+        logger: logger
+      )
+    end
+
+    def build(merge_request:, changes_text:, jira_issue: nil)
+      build_generate_prompt(merge_request: merge_request, changes_text: changes_text, jira_issue: jira_issue)
+    end
+
+    def build_generate_prompt(merge_request:, changes_text:, jira_issue: nil)
+      {
+        system_prompt: system_prompt(GENERATE_PROMPT_TEMPLATE),
+        user_prompt: user_prompt(merge_request: merge_request, changes_text: changes_text, jira_issue: jira_issue)
+      }
+    end
+
+    def build_critique_prompt(merge_request:, changes_text:, candidates_json:, jira_issue: nil)
+      user = "#{user_prompt(merge_request: merge_request, changes_text: changes_text, jira_issue: jira_issue)}\n\n"
+      user << "Candidates JSON from Generate:\n#{scrub_text(candidates_json)}"
+
+      {
+        system_prompt: system_prompt(CRITIQUE_PROMPT_TEMPLATE),
+        user_prompt: user
+      }
+    end
+
+    private
+
+    def system_prompt(template)
+      extras = []
+      if Aireview::Utils.present?(@config.review_instructions)
+        extras << "Additional project instructions:\n#{scrub_text(@config.review_instructions.strip)}"
+      end
+      extras << "Response language: #{language_name(@config.review_language)}."
+
+      [template, *extras].join("\n\n")
+    end
+
+    def user_prompt(merge_request:, changes_text:, jira_issue:)
+      truncated_changes = truncate_changes(scrub_text(changes_text))
+
+      sections = merge_request_sections(merge_request)
+      sections << jira_section(jira_issue) if jira_issue
+      sections << "Changes:\n#{truncated_changes}"
+      sections.join("\n\n")
+    end
+
+    def merge_request_sections(merge_request)
+      source_branch = scrub_text(merge_request['source_branch'])
+      target_branch = scrub_text(merge_request['target_branch'])
+
+      [
+        "MR: #{scrub_text(merge_request['title'])}",
+        "Author: #{scrub_text(merge_request.dig('author', 'name'))}",
+        "Branch: #{source_branch} -> #{target_branch}",
+        "Description:\n#{scrub_optional_text(merge_request['description'])}"
+      ]
+    end
+
+    def jira_section(jira_issue)
+      section = "Jira task (#{scrub_text(jira_issue['key'])}):\n"
+      section << "Summary: #{scrub_text(jira_issue['summary'])}\n"
+      section << "Description:\n#{scrub_optional_text(jira_issue['description'])}"
+
+      comments = jira_issue['comments']
+      return section unless comments && !comments.empty?
+
+      section << "\nRecent comments:\n#{comments.map { |comment| scrub_text(comment) }.join("\n")}"
+    end
+
+    def truncate_changes(changes_text)
+      text = changes_text.to_s
+      return text if text.length <= MAX_DIFF_CHARS
+
+      omitted = text.length - MAX_DIFF_CHARS
+      "#{text[0, MAX_DIFF_CHARS]}\n\n[TRUNCATED #{omitted} chars]"
+    end
+
+    def scrub_optional_text(text)
+      scrubbed = scrub_text(text)
+      Aireview::Utils.presence(scrubbed) || '(empty)'
+    end
+
+    def scrub_text(text)
+      @secret_scrubber.scrub_text(text.to_s)
+    end
+
+    def language_name(code)
+      LANGUAGE_NAMES.fetch(code.to_s, code.to_s)
+    end
+  end
+end

data/lib/aireview/diff_fetcher.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+require_relative 'utils'
+
+module Aireview
+  class DiffFetcher
+    DIFF_UNAVAILABLE = '[DIFF_NOT_AVAILABLE]'
+
+    def initialize(ignore_paths:, logger: Logger.new($stderr))
+      @ignore_paths = Array(ignore_paths).compact
+      @logger = logger
+    end
+
+    def filter(changes)
+      Array(changes).reject do |change|
+        ignored_path?(change['new_path']) || ignored_path?(change['old_path'])
+      end
+    end
+
+    def render(changes)
+      Array(changes).map { |change| render_change(change) }.join("\n")
+    end
+
+    private
+
+    def ignored_path?(path)
+      return false if Aireview::Utils.blank?(path)
+
+      @ignore_paths.any? do |pattern|
+        File.fnmatch?(pattern, path, File::FNM_DOTMATCH | File::FNM_EXTGLOB)
+      end
+    end
+
+    def render_change(change)
+      old_path = change['old_path'] || change['new_path']
+      new_path = change['new_path'] || change['old_path']
+      diff = change['diff'].to_s
+      diff = DIFF_UNAVAILABLE if diff.strip.empty?
+
+      <<~DIFF
+        diff --git a/#{old_path} b/#{new_path}
+        --- a/#{old_path}
+        +++ b/#{new_path}
+        #{diff}
+      DIFF
+    end
+  end
+end

data/lib/aireview/errors.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+module Aireview
+  class Error < StandardError; end
+  class ConfigError < Error; end
+  class ParseError < Error; end
+  class ApiError < Error; end
+  class HelpRequested < Error; end
+end

data/lib/aireview/gitlab_client.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+require 'json'
+require_relative 'utils'
+
+module Aireview
+  class GitlabClient
+    OPEN_TIMEOUT = 10
+    READ_TIMEOUT = 30
+    NOTES_PER_PAGE = 100
+    NOTES_PAGE_LIMIT = 100
+    JOBS_PER_PAGE = 100
+    JOBS_PAGE_LIMIT = 100
+
+    def initialize(base_url:, token:, logger: Logger.new($stderr), connection: nil)
+      require 'faraday'
+
+      raise ConfigError, 'GitLab base URL is required' if Aireview::Utils.blank?(base_url)
+      raise ConfigError, 'GitLab token is required' if Aireview::Utils.blank?(token)
+
+      @logger = logger
+      @token = token
+      @connection = connection || build_connection(base_url)
+    end
+
+    def fetch_merge_request(project_id, iid)
+      get_json("projects/#{project_id}/merge_requests/#{iid}")
+    end
+
+    def fetch_merge_request_changes(project_id, iid)
+      payload = get_json("projects/#{project_id}/merge_requests/#{iid}/changes")
+      Array(payload['changes'])
+    end
+
+    def fetch_current_user
+      get_json('user')
+    end
+
+    # Retry создаёт новый job в том же pipeline. Старые попытки видны только
+    # с include_retried; один лишь новый CI_JOB_ID бывает и после обычного push.
+    def retried_job?(project_id, job_id)
+      current = get_json("projects/#{project_id}/jobs/#{job_id}")
+      validate_retry_job!(current, pipeline: true)
+      path = "projects/#{project_id}/pipelines/#{current.fetch('pipeline').fetch('id')}/jobs"
+
+      (1..JOBS_PAGE_LIMIT).each do |page|
+        jobs = get_json(path, include_retried: true, per_page: JOBS_PER_PAGE, page: page)
+        raise ApiError, 'GitLab Jobs API returned an invalid jobs list' unless jobs.is_a?(Array)
+
+        jobs.each { |job| validate_retry_job!(job) }
+        return true if jobs.any? { |job| previous_attempt?(job, current) }
+        return false if jobs.size < JOBS_PER_PAGE
+      end
+
+      raise ApiError, 'Too many pipeline jobs to determine whether this job is a retry'
+    end
+
+    # Заметки отдаются страницами и сортируются по времени создания, а
+    # обновление комментария в этом порядке его не поднимает: на длинном MR
+    # своё ревью оказывается далеко не на первой странице. Обрывать обход молча
+    # нельзя — по неполному списку ревью решит, что заметки нет, и создаст
+    # вторую, поэтому упираемся в предел с ошибкой. Порядок задаётся явно: от
+    # него зависит, какую из старых заметок без метки подхватит ревью, и
+    # полагаться тут на дефолт API не стоит.
+    def fetch_merge_request_notes(project_id, iid)
+      notes = []
+      page = 1
+
+      loop do
+        batch = Array(
+          get_json(
+            "projects/#{project_id}/merge_requests/#{iid}/notes",
+            order_by: 'created_at', sort: 'desc', per_page: NOTES_PER_PAGE, page: page
+          )
+        )
+        notes.concat(batch)
+        break if batch.size < NOTES_PER_PAGE
+
+        page += 1
+        next unless page > NOTES_PAGE_LIMIT
+
+        raise ApiError, "Merge request has more than #{NOTES_PAGE_LIMIT * NOTES_PER_PAGE} notes"
+      end
+
+      notes
+    end
+
+    def post_merge_request_note(project_id, iid, body)
+      post_json("projects/#{project_id}/merge_requests/#{iid}/notes", body: body)
+    end
+
+    def update_merge_request_note(project_id, iid, note_id, body)
+      put_json("projects/#{project_id}/merge_requests/#{iid}/notes/#{note_id}", body: body)
+    end
+
+    private
+
+    def validate_retry_job!(job, pipeline: false)
+      fields = {'id' => Integer, 'name' => String, 'stage' => String}
+      valid = job.is_a?(Hash) && fields.all? { |key, type| job[key].is_a?(type) }
+      if valid && pipeline
+        data = job['pipeline']
+        valid = data.is_a?(Hash) && data['id'].is_a?(Integer)
+      end
+      raise ApiError, 'GitLab Jobs API returned an invalid job payload' unless valid
+    end
+
+    def previous_attempt?(job, current)
+      job.fetch('id') < current.fetch('id') &&
+        job['name'] == current.fetch('name') && job['stage'] == current.fetch('stage')
+    end
+
+    def build_connection(base_url)
+      Faraday.new(url: "#{base_url}/api/v4/") do |builder|
+        builder.request :json
+        builder.options.open_timeout = OPEN_TIMEOUT
+        builder.options.timeout = READ_TIMEOUT
+        builder.adapter Faraday.default_adapter
+      end
+    end
+
+    def get_json(path, params = {})
+      response = @connection.get(path, params, headers)
+      parse_json(response)
+    rescue Faraday::Error => e
+      raise ApiError, "GitLab API request failed: #{e.message}"
+    end
+
+    def post_json(path, body)
+      response = @connection.post(path) do |request|
+        request.headers.update(headers)
+        request.body = JSON.generate(body)
+      end
+      parse_json(response)
+    rescue Faraday::Error => e
+      raise ApiError, "GitLab API request failed: #{e.message}"
+    end
+
+    def put_json(path, body)
+      response = @connection.put(path) do |request|
+        request.headers.update(headers)
+        request.body = JSON.generate(body)
+      end
+      parse_json(response)
+    rescue Faraday::Error => e
+      raise ApiError, "GitLab API request failed: #{e.message}"
+    end
+
+    def parse_json(response)
+      status = response.status.to_i
+      body = response.body.to_s
+
+      return JSON.parse(body) if status.between?(200, 299)
+
+      raise ApiError, "GitLab API error #{status}: #{body}"
+    rescue JSON::ParserError
+      raise ApiError, "GitLab API returned invalid JSON: #{body}"
+    end
+
+    def headers
+      {
+        'Content-Type' => 'application/json',
+        'PRIVATE-TOKEN' => @token
+      }
+    end
+  end
+end