Wire predicates analyzer into constable command

Make the new check runnable via constable alongside existing
analyzers, with CLI coverage for failing and passing cases.

Author: nnutter

README.md

@@ -78,6 +78,24 @@ constable -complexity.limit=15 ./...
 
 The limit defaults to 10 and is configured with `-complexity.limit`.
 
+## Predicates
+
+The predicates analyzer reports `&&` and `||` operands, except the
+first, that are not predicate-function calls. The first operand always
+executes, so coverage observes short-circuiting through the rest.
+
+```go
+if a && b { // reported: use a && isB()
+}
+
+if a && isB() { // allowed
+}
+```
+
+The check also covers `for` conditions and bool assignments such as
+`c := a && b`, including negated variables, field and map access,
+and comparisons.
+
 ## Development
 
 Run all fixers,

SKILL.md

@@ -111,6 +111,31 @@ func (c Count) Increment() Count {
 }
 ```
 
+## Predicates
+
+The predicates analyzer reports `&&` and `||` operands, except the
+first, that are not predicate-function calls. The first operand always
+executes, so coverage observes short-circuiting through the rest.
+
+```go
+func F(a, b bool) {
+ if a && b { // reported: use a && isB()
+ }
+}
+
+func isB() bool { return false }
+
+func G(a bool) {
+ if a && isB() { // allowed
+ }
+}
+```
+
+The check covers `if` and `for` conditions and bool assignments such
+as `c := a && b`, including `!a`, field and map access, and
+comparisons. Operands that are already calls, compound expressions,
+or `true`/`false`/`nil` are allowed.
+
 ## Agent workflow
 
 1. Identify functions and methods whose API contract should not mutate caller-owned data.

cmd/constable/main.go

@@ -4,6 +4,7 @@ import (
 	"github.com/nnutter/constable/internal/analysis/complexity"
 	"github.com/nnutter/constable/internal/analysis/methodical"
 	"github.com/nnutter/constable/internal/analysis/nonmutating"
+	"github.com/nnutter/constable/internal/analysis/predicates"
 	"github.com/nnutter/constable/internal/analysis/testify"
 	"github.com/nnutter/constable/internal/driver"
 )
@@ -14,5 +15,5 @@ import (
 var version string
 
 func main() {
-	driver.Main(version, nonmutating.Analyzer, methodical.Analyzer, testify.Analyzer, complexity.Analyzer)
+	driver.Main(version, nonmutating.Analyzer, methodical.Analyzer, predicates.Analyzer, testify.Analyzer, complexity.Analyzer)
 }

cmd/constable/main_test.go

@@ -226,6 +226,61 @@ func TestCLIComplexityFail(t *testing.T) {
 	assert.NotContains(t, output, moduleDir)
 }
 
+func TestCLIPredicatesFail(t *testing.T) {
+	binary := buildBinary(t)
+	moduleDir := writeModule(t, module{
+		GoMod: []string{
+			"module example.com/predicates",
+			"",
+			"go 1.26",
+		},
+		Files: map[string][]string{"a.go": {
+			"package predicates",
+			"",
+			"func F(a, b bool) {",
+			"\tif a && b {",
+			"\t\tprintln(\"both\")",
+			"\t}",
+			"}",
+		}},
+	})
+
+	output, err := runConstable(t, binary, moduleDir)
+
+	require.Error(t, err)
+	assert.Contains(t, output, `use predicate function instead of "b" in compound conditional`)
+	assert.NotContains(t, output, moduleDir)
+}
+
+func TestCLIPredicatesPass(t *testing.T) {
+	binary := buildBinary(t)
+	moduleDir := writeModule(t, module{
+		GoMod: []string{
+			"module example.com/predicatespass",
+			"",
+			"go 1.26",
+		},
+		Files: map[string][]string{"a.go": {
+			"package predicates",
+			"",
+			"func isA() bool { return true }",
+			"",
+			"func isB() bool { return false }",
+			"",
+			"func F() {",
+			"\tif isA() && isB() {",
+			"\t\tprintln(\"both\")",
+			"\t}",
+			"}",
+		}},
+	})
+
+	output, err := runConstable(t, binary, moduleDir)
+
+	require.NoError(t, err, output)
+	assert.Empty(t, output)
+}
+
 func TestCLIComplexityPass(t *testing.T) {
 	binary := buildBinary(t)