Add a labels predicate with has_any, has_all, and has_none (#1421)

Adds a labels predicate with optional has_any/has_all/has_none sub-keys,
structured like the title and repository predicates. Sub-keys combine with
AND and matching is case-insensitive. has_labels is deprecated and now
calls the new labels implementation.

Author: 0x000NULL

README.md

@@ -461,12 +461,28 @@ if:
       - ".github/workflows/a.yml"
       - ".github/workflows/b.yml"
 
+  # DEPRECATED: Use "labels" below instead, which is more flexible.
   # "has_labels" is satisfied if the pull request has the specified labels
   # applied
   has_labels:
     - "label-1"
     - "label-2"
 
+  # "labels" is satisfied based on the labels applied to the pull request.
+  # Each sub-key is optional; when more than one is set, all must be
+  # satisfied. Label matching is case-insensitive.
+  labels:
+    # satisfied if the pull request has at least one of these labels
+    has_any:
+      - "label-1"
+      - "label-2"
+    # satisfied if the pull request has all of these labels
+    has_all:
+      - "label-3"
+    # satisfied if the pull request has none of these labels
+    has_none:
+      - "do-not-merge"
+
   # "repository" is satisfied if the pull request repository matches any one of the
   # patterns within the "matches" list or does not match all of the patterns
   # within the "not_matches" list.

policy/predicate/label.go

@@ -17,41 +17,20 @@ package predicate
 import (
 	"context"
 	"slices"
-	"strings"
 
 	"github.com/palantir/policy-bot/policy/common"
 	"github.com/palantir/policy-bot/pull"
-	"github.com/pkg/errors"
 )
 
+// HasLabels checks that the pull request has all of the specified labels.
+//
+// Deprecated: use the more flexible `Labels` with `has_all` instead.
 type HasLabels []string
 
 var _ Predicate = HasLabels([]string{})
 
 func (pred HasLabels) Evaluate(ctx context.Context, prctx pull.Context) (*common.PredicateResult, error) {
-
-	predicateResult := common.PredicateResult{
-		ValuePhrase:     "labels",
-		ConditionPhrase: "contain the labels",
-	}
-	if len(pred) > 0 {
-		labels, err := prctx.Labels()
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to list pull request labels")
-		}
-		predicateResult.Values = labels
-		for _, requiredLabel := range pred {
-			if !contains(labels, strings.ToLower(requiredLabel)) {
-				predicateResult.ConditionValues = []string{requiredLabel}
-				predicateResult.Description = "Missing label: " + requiredLabel
-				predicateResult.Satisfied = false
-				return &predicateResult, nil
-			}
-		}
-	}
-	predicateResult.ConditionValues = pred
-	predicateResult.Satisfied = true
-	return &predicateResult, nil
+	return Labels{HasAll: pred}.Evaluate(ctx, prctx)
 }
 
 func (pred HasLabels) Trigger() common.Trigger {

policy/predicate/label_test.go

@@ -34,9 +34,9 @@ func TestHasLabels(t *testing.T) {
 				LabelsValue: []string{"foo", "bar"},
 			},
 			&common.PredicateResult{
-				Satisfied:       true,
-				Values:          []string{"foo", "bar"},
-				ConditionValues: []string{"foo", "bar"},
+				Satisfied:     true,
+				Values:        []string{"foo", "bar"},
+				ConditionsMap: map[string][]string{"has all of": {"foo", "bar"}},
 			},
 		},
 		{
@@ -45,9 +45,9 @@ func TestHasLabels(t *testing.T) {
 				LabelsValue: []string{"foo"},
 			},
 			&common.PredicateResult{
-				Satisfied:       false,
-				Values:          []string{"foo"},
-				ConditionValues: []string{"bar"},
+				Satisfied:     false,
+				Values:        []string{"foo"},
+				ConditionsMap: map[string][]string{"has all of": {"foo", "bar"}},
 			},
 		},
 		{
@@ -56,9 +56,9 @@ func TestHasLabels(t *testing.T) {
 				LabelsValue: []string{},
 			},
 			&common.PredicateResult{
-				Satisfied:       false,
-				Values:          []string{},
-				ConditionValues: []string{"foo"},
+				Satisfied:     false,
+				Values:        []string{},
+				ConditionsMap: map[string][]string{"has all of": {"foo", "bar"}},
 			},
 		},
 	})

policy/predicate/labels.go

@@ -0,0 +1,104 @@
+// Copyright 2026 Palantir Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package predicate
+
+import (
+	"context"
+	"strings"
+
+	"github.com/palantir/policy-bot/policy/common"
+	"github.com/palantir/policy-bot/pull"
+	"github.com/pkg/errors"
+)
+
+// Labels is satisfied based on the set of labels applied to the pull request.
+// Each sub-key is optional; when more than one is set, all must be satisfied
+// (they combine with AND). Label matching is case-insensitive, matching the
+// behavior of the has_labels predicate.
+type Labels struct {
+	HasAny  []string `yaml:"has_any,omitempty"`
+	HasAll  []string `yaml:"has_all,omitempty"`
+	HasNone []string `yaml:"has_none,omitempty"`
+}
+
+var _ Predicate = Labels{}
+
+func (pred Labels) Evaluate(ctx context.Context, prctx pull.Context) (*common.PredicateResult, error) {
+	labels, err := prctx.Labels()
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to list pull request labels")
+	}
+
+	predicateResult := common.PredicateResult{
+		ValuePhrase:     "labels",
+		Values:          labels,
+		ConditionPhrase: "satisfy the label requirements",
+		ConditionsMap:   map[string][]string{},
+	}
+
+	satisfied := true
+
+	if len(pred.HasAny) > 0 {
+		predicateResult.ConditionsMap["has any of"] = pred.HasAny
+		if !anyLabel(labels, pred.HasAny) {
+			satisfied = false
+		}
+	}
+	if len(pred.HasAll) > 0 {
+		predicateResult.ConditionsMap["has all of"] = pred.HasAll
+		if !allLabels(labels, pred.HasAll) {
+			satisfied = false
+		}
+	}
+	if len(pred.HasNone) > 0 {
+		predicateResult.ConditionsMap["has none of"] = pred.HasNone
+		if anyLabel(labels, pred.HasNone) {
+			satisfied = false
+		}
+	}
+
+	predicateResult.Satisfied = satisfied
+	predicateResult.Description = "The labels do not meet the required conditions"
+	if satisfied {
+		predicateResult.Description = "The labels meet the required conditions"
+	}
+	return &predicateResult, nil
+}
+
+func (pred Labels) Trigger() common.Trigger {
+	return common.TriggerLabel
+}
+
+// anyLabel reports whether at least one of the required labels is present.
+// prctx.Labels() returns lowercased values, so the configured labels are
+// lowercased before comparison to keep matching case-insensitive.
+func anyLabel(labels, required []string) bool {
+	for _, r := range required {
+		if contains(labels, strings.ToLower(r)) {
+			return true
+		}
+	}
+	return false
+}
+
+// allLabels reports whether every required label is present.
+func allLabels(labels, required []string) bool {
+	for _, r := range required {
+		if !contains(labels, strings.ToLower(r)) {
+			return false
+		}
+	}
+	return true
+}