gitlab-branch-triage 1.0.0

data/lib/gitlab/branch_triage/actions/mr_actions.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module Gitlab
+  module BranchTriage
+    module Actions
+      # ── comment_mr ───────────────────────────────────────────────────────
+      # Posts a note directly on the MR thread.
+      #
+      # comment_mr: |
+      #   @{{author_username}} this MR has been inactive for {{days_since_update}} days.
+      #   Please update it or it will be closed on {{close_date}}.
+      class CommentMr < Base
+        def execute
+          body = render(config.to_s)
+
+          if dry_run
+            log_dry("Would comment on MR !#{mr.iid}: #{body[0, 80].inspect}...")
+            return
+          end
+
+          client.add_mr_note(project_id, mr.iid, body)
+          log_ok("Commented on MR !#{mr.iid}")
+        rescue => e
+          log_err("Failed to comment on MR !#{mr.iid}: #{e.message}")
+        end
+
+        private
+
+        def mr = @branch
+      end
+
+      # ── close_mr ─────────────────────────────────────────────────────────
+      # Closes the MR via the API.
+      #
+      # close_mr: true
+      class CloseMr < Base
+        def execute
+          return unless config
+
+          if dry_run
+            log_dry("Would close MR !#{mr.iid}: #{mr.title.slice(0, 60).inspect}")
+            return
+          end
+
+          client.close_mr(project_id, mr.iid)
+          log_ok("Closed MR !#{mr.iid}: #{mr.title.slice(0, 60)}")
+        rescue => e
+          log_err("Failed to close MR !#{mr.iid}: #{e.message}")
+        end
+
+        private
+
+        def mr = @branch
+      end
+
+      # ── label_mr ─────────────────────────────────────────────────────────
+      # Adds labels to the MR.
+      #
+      # label_mr:
+      #   - stale
+      #   - needs-attention
+      class LabelMr < Base
+        def execute
+          labels = Array(config)
+          return if labels.empty?
+
+          if dry_run
+            log_dry("Would add labels #{labels.inspect} to MR !#{mr.iid}")
+            return
+          end
+
+          client.add_mr_labels(project_id, mr.iid, labels)
+          log_ok("Added labels #{labels.inspect} to MR !#{mr.iid}")
+        rescue => e
+          log_err("Failed to label MR !#{mr.iid}: #{e.message}")
+        end
+
+        private
+
+        def mr = @branch
+      end
+
+      # ── notify_mr ────────────────────────────────────────────────────────
+      # Creates a GitLab issue to notify the author of an abandoned MR.
+      #
+      # notify_mr:
+      #   title: "Abandoned MR: {{title}}"
+      #   body: |
+      #     @{{author_username}}, MR !{{iid}} has been inactive for {{days_since_update}} days.
+      #   labels:
+      #     - mr-cleanup
+      class NotifyMr < Base
+        DEFAULT_TITLE = "Abandoned MR: !{{iid}} {{title}}"
+        DEFAULT_BODY  = <<~BODY
+          Hi @{{author_username}} 👋
+
+          Merge Request [!{{iid}} {{title}}]({{web_url}}) in project `{{project_path}}`
+          has been inactive for **{{days_since_update}} days**
+          (last update: `{{updated_at}}`).
+
+          **Status:** {{state}}{{draft_label}}
+
+          Please take one of the following actions before **{{close_date}}**:
+          - ✅ Mark it as ready and request a review
+          - 🔄 Rebase/update if there are conflicts
+          - 🚫 Close it if the work is no longer needed
+
+          _This issue was created automatically by gitlab-branch-triage._
+        BODY
+
+        def execute
+          title_tpl = config.is_a?(Hash) ? config["title"] || DEFAULT_TITLE : DEFAULT_TITLE
+          body_tpl  = config.is_a?(Hash) ? config["body"]  || DEFAULT_BODY  : DEFAULT_BODY
+          labels    = config.is_a?(Hash) ? Array(config["labels"])           : ["mr-cleanup", "automated"]
+
+          close_in   = mr.instance_variable_defined?(:@close_in_days) ? mr.instance_variable_get(:@close_in_days) : 30
+          close_date = (Time.now + close_in * 86_400).strftime("%Y-%m-%d")
+          draft_lbl  = mr.draft? ? " (Draft/WIP)" : ""
+
+          extra = { "close_date" => close_date, "draft_label" => draft_lbl }
+          title = render(title_tpl, extra)
+          body  = render(body_tpl,  extra)
+
+          if dry_run
+            log_dry("Would create issue: #{title.inspect}")
+            return
+          end
+
+          issue = client.create_issue(
+            project_id,
+            title:       title,
+            description: body,
+            labels:      labels,
+            assignee_id: mr.author_id
+          )
+          log_ok("Issue created: #{issue["web_url"]}")
+        rescue => e
+          log_err("Failed to create issue for MR !#{mr.iid}: #{e.message}")
+        end
+
+        private
+
+        def mr = @branch
+      end
+
+      # ── MR Action Executor ────────────────────────────────────────────────
+
+      MR_REGISTRY = {
+        "comment_mr" => CommentMr,
+        "close_mr"   => CloseMr,
+        "label_mr"   => LabelMr,
+        "notify_mr"  => NotifyMr,
+        "print"      => Print,   # shared with branch actions
+      }.freeze
+
+      class MrExecutor
+        def initialize(client:, project_id:, mr:, actions:, dry_run: true, logger: Logger.new($stdout))
+          @client     = client
+          @project_id = project_id
+          @mr         = mr
+          @actions    = actions || {}
+          @dry_run    = dry_run
+          @logger     = logger
+        end
+
+        def execute!
+          @actions.each do |key, config|
+            klass = MR_REGISTRY[key]
+            if klass.nil?
+              @logger.warn("  Unknown MR action '#{key}' — ignored")
+              next
+            end
+
+            klass.new(
+              client:     @client,
+              project_id: @project_id,
+              branch:     @mr,      # reuse :branch slot for MR
+              config:     config,
+              dry_run:    @dry_run,
+              logger:     @logger
+            ).execute
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/branch_triage/actions/notify.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Gitlab
+  module BranchTriage
+    module Actions
+      # notify:
+      #   title: "🔔 Stale branch: {{name}}"
+      #   body: |
+      #     @{{author_username}}, branch `{{name}}` inactive for {{days_inactive}} days.
+      #   labels:
+      #     - branch-cleanup
+      #
+      # Behaviour when author is inactive/blocked/deleted:
+      #   → Branch is deleted automatically (no point notifying a ghost).
+      #   → An issue is still created and assigned to a project owner so the
+      #     team knows a cleanup happened.
+      class Notify < Base
+        DEFAULT_TITLE = "🔔 Stale branch: `{{name}}`"
+        DEFAULT_BODY  = <<~BODY
+          Hi @{{author_username}} 👋
+
+          Branch `{{name}}` has been inactive for **{{days_inactive}} days**
+          (last commit on `{{committed_date}}`).
+
+          It will be **automatically deleted on {{delete_date}}** unless you take action.
+
+          **What you can do:**
+          - 🔀 Open a Merge Request if this work needs to be merged
+          - 🗑️ Delete the branch manually if it's no longer needed
+          - 💬 Comment on this issue to request more time
+
+          _This issue was created automatically by gitlab-branch-triage._
+        BODY
+
+        INACTIVE_AUTHOR_TITLE = "🗑️ Branch auto-deleted: `{{name}}` (author inactive)"
+        INACTIVE_AUTHOR_BODY  = <<~BODY
+          Branch `{{name}}` was **automatically deleted** because its author
+          is no longer active on this GitLab instance.
+
+          | Field | Value |
+          |-------|-------|
+          | Branch | `{{name}}` |
+          | Last commit | `{{committed_date}}` |
+          | Days inactive | {{days_inactive}} |
+          | Git author | {{author_name}} &lt;{{author_email}}&gt; |
+          | Author status | {{author_status}} |
+
+          _This issue was created automatically by gitlab-branch-triage._
+        BODY
+
+        def execute
+          resolver = UserResolver.new(client: client, logger: logger)
+          result   = resolver.resolve(
+            email: branch.author_email,
+            name:  branch.author_name
+          )
+
+          logger.info("    Author resolution: #{result.display}")
+
+          if result.inactive?
+            handle_inactive_author(result, resolver)
+          else
+            # Store resolved user on branch for template rendering
+            branch.author_user = result.user
+            notify_active_author
+          end
+        end
+
+        private
+
+        # ── Inactive author → delete branch + notify owners ──────────────────
+
+        def handle_inactive_author(result, resolver)
+          logger.info("    Author is inactive (#{result.status}) — branch will be deleted")
+
+          # 1. Delete the branch
+          if dry_run
+            log_dry("Would delete branch #{branch.name.inspect} (inactive author: #{result.status})")
+          else
+            ok = client.delete_branch(project_id, branch.name)
+            if ok
+              log_ok("Branch deleted: #{branch.name.inspect} (author #{result.status})")
+            else
+              log_err("Failed to delete branch #{branch.name.inspect}")
+              return
+            end
+          end
+
+          # 2. Notify owners so they're aware of the cleanup
+          owners = resolver.project_owners(project_id)
+          owner  = owners.first
+          logger.warn("    No project owners/maintainers found for #{project_id}") if owner.nil?
+
+          title = render(INACTIVE_AUTHOR_TITLE)
+          body  = render(INACTIVE_AUTHOR_BODY, "author_status" => result.status.to_s)
+
+          if dry_run
+            log_dry("Would create cleanup issue for owners: #{title.inspect}")
+            return
+          end
+
+          issue = client.create_issue(
+            project_id,
+            title:       title,
+            description: body,
+            labels:      ["branch-cleanup", "author-inactive", "automated"],
+            assignee_id: owner&.dig("id")
+          )
+          log_ok("Cleanup issue created for owners: #{issue["web_url"]}")
+        rescue => e
+          log_err("Error handling inactive author for #{branch.name}: #{e.message}")
+        end
+
+        # ── Active author → normal notification ───────────────────────────────
+
+        def notify_active_author
+          title_tpl  = config.is_a?(Hash) ? config["title"] || DEFAULT_TITLE : DEFAULT_TITLE
+          body_tpl   = config.is_a?(Hash) ? config["body"]  || DEFAULT_BODY  : DEFAULT_BODY
+          labels     = config.is_a?(Hash) ? Array(config["labels"])           : []
+          delete_in  = branch.delete_in_days || 30
+
+          delete_date = (Time.now + delete_in * 86_400).strftime("%Y-%m-%d")
+          title = render(title_tpl, "delete_date" => delete_date)
+          body  = render(body_tpl,  "delete_date" => delete_date)
+
+          if dry_run
+            log_dry("Would create issue: #{title.inspect}")
+            return
+          end
+
+          issue = client.create_issue(
+            project_id,
+            title:       title,
+            description: body,
+            labels:      labels,
+            assignee_id: branch.author_user&.dig("id")
+          )
+          log_ok("Issue created: #{issue["web_url"]}")
+        rescue => e
+          log_err("Failed to create issue: #{e.message}")
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/branch_triage/actions/print.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Gitlab
+  module BranchTriage
+    module Actions
+      # print: "Branch {{name}} is {{days_inactive}} days old."
+      class Print < Base
+        def execute
+          msg = render(config.to_s)
+          logger.info("  📢 #{msg}")
+        end
+      end
+
+      # comment:
+      #   issue_iid: 42
+      #   body: "Reminder: {{name}} is still inactive after {{days_inactive}} days."
+      class Comment < Base
+        def execute
+          unless config.is_a?(Hash) && config["issue_iid"] && config["body"]
+            log_err("'comment' action requires 'issue_iid' and 'body' keys")
+            return
+          end
+
+          body = render(config["body"])
+          iid  = config["issue_iid"].to_i
+
+          if dry_run
+            log_dry("Would comment on issue ##{iid}: #{body[0, 80].inspect}...")
+            return
+          end
+
+          client.add_note(project_id, iid, body)
+          log_ok("Commented on issue ##{iid}")
+        rescue => e
+          log_err("Failed to comment: #{e.message}")
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/branch_triage/client.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Gitlab
+  module BranchTriage
+    class Client
+      include HTTParty
+
+      BASE_PATH = "/api/v4"
+
+      attr_reader :host_url, :logger
+
+      def initialize(host_url:, token:, logger: Logger.new($stdout))
+        @host_url = host_url.chomp("/")
+        @token    = token
+        @logger   = logger
+
+        self.class.base_uri "#{@host_url}#{BASE_PATH}"
+        self.class.headers "PRIVATE-TOKEN" => token, "Content-Type" => "application/json"
+      end
+
+      # ── Branch endpoints ───────────────────────────────────────────────────
+
+      def branches(project_id)
+        paginate("/projects/#{encode(project_id)}/repository/branches")
+      end
+
+      def delete_branch(project_id, branch_name)
+        path = "/projects/#{encode(project_id)}/repository/branches/#{encode(branch_name)}"
+        resp = self.class.delete(path)
+        handle_response!(resp, expect: 204)
+        true
+      end
+
+      # ── Merge Request endpoints ────────────────────────────────────────────
+
+      def open_mr_source_branches(project_id)
+        mrs = paginate("/projects/#{encode(project_id)}/merge_requests", state: "opened")
+        mrs.map { |mr| mr["source_branch"] }.to_set
+      end
+
+      def merge_requests(project_id, state: "opened")
+        paginate("/projects/#{encode(project_id)}/merge_requests", state: state)
+      end
+
+      def add_mr_note(project_id, mr_iid, body)
+        resp = self.class.post(
+          "/projects/#{encode(project_id)}/merge_requests/#{mr_iid}/notes",
+          body: { body: body }.to_json
+        )
+        handle_response!(resp, expect: 201)
+        resp.parsed_response
+      end
+
+      def close_mr(project_id, mr_iid)
+        resp = self.class.put(
+          "/projects/#{encode(project_id)}/merge_requests/#{mr_iid}",
+          body: { state_event: "close" }.to_json
+        )
+        handle_response!(resp)
+        resp.parsed_response
+      end
+
+      def add_mr_labels(project_id, mr_iid, labels)
+        resp = self.class.put(
+          "/projects/#{encode(project_id)}/merge_requests/#{mr_iid}",
+          body: { add_labels: labels.join(",") }.to_json
+        )
+        handle_response!(resp)
+        resp.parsed_response
+      end
+
+      # ── Issue endpoints ────────────────────────────────────────────────────
+
+      def create_issue(project_id, title:, description:, labels: [], assignee_id: nil)
+        payload = { title: title, description: description, labels: labels.join(",") }
+        payload[:assignee_id] = assignee_id if assignee_id
+
+        resp = self.class.post("/projects/#{encode(project_id)}/issues", body: payload.to_json)
+        handle_response!(resp, expect: 201)
+        resp.parsed_response
+      end
+
+      def add_note(project_id, issue_iid, body)
+        resp = self.class.post(
+          "/projects/#{encode(project_id)}/issues/#{issue_iid}/notes",
+          body: { body: body }.to_json
+        )
+        handle_response!(resp, expect: 201)
+        resp.parsed_response
+      end
+
+      # ── Group endpoints ───────────────────────────────────────────────────
+
+      # Returns all projects in a group, including subgroups recursively.
+      # The GitLab API supports include_subgroups=true natively.
+      def group_projects(group_id, include_subgroups: true)
+        paginate(
+          "/groups/#{encode(group_id)}/projects",
+          include_subgroups: include_subgroups,
+          with_shared:       false
+        )
+      end
+
+      # ── User endpoints ─────────────────────────────────────────────────────
+
+      # Search users — includes blocked users if token has admin scope,
+      # otherwise only returns active accounts.
+      def find_users(search, per_page: 5)
+        resp = self.class.get("/users", query: { search: search, per_page: per_page })
+        data = resp.parsed_response
+        data.is_a?(Array) ? data : []
+      end
+
+      # Kept for backward compat
+      def find_user(search)
+        find_users(search, per_page: 1).first
+      end
+
+      # Returns project members with at least min_access_level.
+      # access_level: 40 = Maintainer, 50 = Owner
+      def project_members(project_id, min_access_level: 40)
+        paginate(
+          "/projects/#{encode(project_id)}/members/all",
+          min_access_level: min_access_level
+        )
+      end
+
+      private
+
+      MAX_RETRIES = 5
+
+      def paginate(path, extra_params = {})
+        results = []
+        page    = 1
+        retries = 0
+
+        loop do
+          resp = self.class.get(path, query: { per_page: 100, page: page }.merge(extra_params))
+
+          # Handle rate limiting with max retries
+          if resp.code == 429
+            retries += 1
+            raise "Rate limited by GitLab API after #{MAX_RETRIES} retries" if retries > MAX_RETRIES
+
+            wait = (resp.headers["retry-after"] || 10).to_i
+            @logger.warn("Rate limited — waiting #{wait}s (retry #{retries}/#{MAX_RETRIES})")
+            sleep(wait)
+            next
+          end
+
+          retries = 0  # reset on success
+
+          handle_response!(resp)
+          data = resp.parsed_response
+          break if data.empty?
+
+          results.concat(data)
+          break if data.size < 100
+
+          page += 1
+        end
+
+        results
+      end
+
+      def handle_response!(resp, expect: 200)
+        return if resp.code == expect || (expect == 200 && resp.success?)
+
+        raise "GitLab API error #{resp.code}: #{resp.body&.slice(0, 200)}"
+      end
+
+      def encode(str)
+        URI.encode_www_form_component(str.to_s)
+      end
+    end
+  end
+end

data/lib/gitlab/branch_triage/conditions/author_condition.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Gitlab
+  module BranchTriage
+    module Conditions
+      # author:
+      #   email_domain: "company.com"
+      #   name_matches: "^John.*"
+      #   username: "john.doe"
+      class AuthorCondition < Base
+        def satisfied?
+          match_author?
+        end
+
+        protected
+
+        def match_author?
+          if config.key?("email_domain")
+            return branch.author_email.end_with?("@#{config["email_domain"]}")
+          end
+          if config.key?("name_matches")
+            return Regexp.new(config["name_matches"]).match?(branch.author_name)
+          end
+          if config.key?("username")
+            term = config["username"]
+            return branch.author_email.include?(term) || branch.author_name.include?(term)
+          end
+          true
+        end
+      end
+
+      # forbidden_author: — inverse of AuthorCondition
+      class ForbiddenAuthor < AuthorCondition
+        def satisfied?
+          !match_author?
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/branch_triage/conditions/base.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Gitlab
+  module BranchTriage
+    module Conditions
+      class Base
+        attr_reader :branch, :config
+
+        def initialize(branch, config)
+          @branch = branch
+          @config = config
+        end
+
+        # Subclasses must implement #satisfied?
+        def satisfied?
+          raise NotImplementedError, "#{self.class}#satisfied? not implemented"
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/branch_triage/conditions/date_condition.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Gitlab
+  module BranchTriage
+    module Conditions
+      # date:
+      #   attribute: committed_date
+      #   condition: older_than | more_recent_than
+      #   interval_type: days | weeks | months | years
+      #   interval: 60
+      class DateCondition < Base
+        MULTIPLIERS = {
+          "days"   => 1,
+          "weeks"  => 7,
+          "months" => 30,
+          "years"  => 365,
+        }.freeze
+
+        def satisfied?
+          threshold_days = config["interval"].to_i * MULTIPLIERS.fetch(config["interval_type"] || "days", 1)
+          age_days       = branch.days_inactive
+
+          case config["condition"]
+          when "older_than"     then age_days >= threshold_days
+          when "more_recent_than" then age_days < threshold_days
+          else
+            warn "Unknown date condition: #{config["condition"]}"
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/branch_triage/conditions/evaluator.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Gitlab
+  module BranchTriage
+    module Conditions
+      # Maps condition keys from the YAML to their handler classes.
+      REGISTRY = {
+        "date"             => DateCondition,
+        "inactive_days"    => InactiveDays,
+        "name"             => NameCondition,
+        "forbidden_name"   => ForbiddenName,
+        "merged"           => nil,   # handled inline (StateCondition)
+        "protected"        => nil,
+        "has_open_mr"      => nil,
+        "author"           => AuthorCondition,
+        "forbidden_author" => ForbiddenAuthor,
+      }.freeze
+
+      STATE_KEYS = %w[merged protected has_open_mr].freeze
+
+      class Evaluator
+        def initialize(branch, conditions)
+          @branch     = branch
+          @conditions = conditions || {}
+        end
+
+        # Returns true if ALL conditions are satisfied.
+        def satisfied?
+          @conditions.all? do |key, value|
+            evaluate_condition(key, value)
+          end
+        end
+
+        private
+
+        def evaluate_condition(key, value)
+          if STATE_KEYS.include?(key)
+            return StateCondition.for(key, @branch, value).satisfied?
+          end
+
+          klass = REGISTRY[key]
+          if klass.nil? && !STATE_KEYS.include?(key)
+            warn "  ⚠️  Unknown condition '#{key}' — ignored"
+            return true
+          end
+
+          klass.new(@branch, value).satisfied?
+        end
+      end
+    end
+  end
+end