feat(rubric): add IntegerScore type for 1-5 scale scoring

Add IntegerScore type with constants for the 5-level evaluation scale:
- ScoreUnacceptable (1), ScoreMajorRevisions (2), ScoreAcceptable (3)
- ScoreGood (4), ScoreExcellent (5)

Includes helper methods:
- String() for human-readable labels
- ToCategorical() to convert to pass/partial/fail
- IsValid() to check range validity
- ParseIntegerScore() to parse from int

This scale is preferred for LLM judges as research shows they are
unreliable at finer granularity than 5 levels.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: grokify

rubric/score.go

@@ -0,0 +1,95 @@
+package rubric
+
+// IntegerScore represents a 1-5 integer evaluation score.
+// This scale is preferred for LLM judges as research shows they are
+// unreliable at finer granularity than 5 levels.
+type IntegerScore int
+
+const (
+	// ScoreUnacceptable indicates the spec does not meet requirements.
+	ScoreUnacceptable IntegerScore = 1
+
+	// ScoreMajorRevisions indicates significant work is needed.
+	ScoreMajorRevisions IntegerScore = 2
+
+	// ScoreAcceptable indicates minimum requirements are met.
+	ScoreAcceptable IntegerScore = 3
+
+	// ScoreGood indicates the spec meets expectations well.
+	ScoreGood IntegerScore = 4
+
+	// ScoreExcellent indicates the spec exceeds expectations.
+	ScoreExcellent IntegerScore = 5
+)
+
+// String returns the human-readable label for the score.
+func (s IntegerScore) String() string {
+	labels := []string{"", "Unacceptable", "Major Revisions", "Acceptable", "Good", "Excellent"}
+	if s >= 1 && s <= 5 {
+		return labels[s]
+	}
+	return "Unknown"
+}
+
+// ToCategorical converts the integer score to a categorical ScoreValue.
+// 1-2 = fail, 3 = partial, 4-5 = pass
+func (s IntegerScore) ToCategorical() ScoreValue {
+	switch {
+	case s <= 2:
+		return ScoreFail
+	case s == 3:
+		return ScorePartial
+	default:
+		return ScorePass
+	}
+}
+
+// IsValid returns true if the score is in the valid 1-5 range.
+func (s IntegerScore) IsValid() bool {
+	return s >= 1 && s <= 5
+}
+
+// IsPassing returns true if the score is considered passing (4 or higher).
+func (s IntegerScore) IsPassing() bool {
+	return s >= ScoreGood
+}
+
+// Icon returns the emoji icon for the score.
+func (s IntegerScore) Icon() string {
+	switch s {
+	case ScoreExcellent:
+		return "🌟"
+	case ScoreGood:
+		return "🟢"
+	case ScoreAcceptable:
+		return "🟡"
+	case ScoreMajorRevisions:
+		return "🟠"
+	case ScoreUnacceptable:
+		return "🔴"
+	default:
+		return "⚪"
+	}
+}
+
+// ParseIntegerScore converts an integer to IntegerScore, clamping to valid range.
+func ParseIntegerScore(score int) IntegerScore {
+	if score < 1 {
+		return ScoreUnacceptable
+	}
+	if score > 5 {
+		return ScoreExcellent
+	}
+	return IntegerScore(score)
+}
+
+// AllIntegerScores returns all valid integer scores in descending order.
+func AllIntegerScores() []IntegerScore {
+	return []IntegerScore{
+		ScoreExcellent,
+		ScoreGood,
+		ScoreAcceptable,
+		ScoreMajorRevisions,
+		ScoreUnacceptable,
+	}
+}

rubric/score_test.go

@@ -0,0 +1,121 @@
+package rubric
+
+import "testing"
+
+func TestIntegerScore_String(t *testing.T) {
+	tests := []struct {
+		score IntegerScore
+		want  string
+	}{
+		{ScoreUnacceptable, "Unacceptable"},
+		{ScoreMajorRevisions, "Major Revisions"},
+		{ScoreAcceptable, "Acceptable"},
+		{ScoreGood, "Good"},
+		{ScoreExcellent, "Excellent"},
+		{IntegerScore(0), "Unknown"},
+		{IntegerScore(6), "Unknown"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.want, func(t *testing.T) {
+			if got := tt.score.String(); got != tt.want {
+				t.Errorf("IntegerScore(%d).String() = %q, want %q", tt.score, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestIntegerScore_ToCategorical(t *testing.T) {
+	tests := []struct {
+		score IntegerScore
+		want  ScoreValue
+	}{
+		{ScoreUnacceptable, ScoreFail},
+		{ScoreMajorRevisions, ScoreFail},
+		{ScoreAcceptable, ScorePartial},
+		{ScoreGood, ScorePass},
+		{ScoreExcellent, ScorePass},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.score.String(), func(t *testing.T) {
+			if got := tt.score.ToCategorical(); got != tt.want {
+				t.Errorf("IntegerScore(%d).ToCategorical() = %s, want %s", tt.score, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestIntegerScore_IsValid(t *testing.T) {
+	tests := []struct {
+		score IntegerScore
+		want  bool
+	}{
+		{IntegerScore(0), false},
+		{ScoreUnacceptable, true},
+		{ScoreMajorRevisions, true},
+		{ScoreAcceptable, true},
+		{ScoreGood, true},
+		{ScoreExcellent, true},
+		{IntegerScore(6), false},
+	}
+
+	for _, tt := range tests {
+		if got := tt.score.IsValid(); got != tt.want {
+			t.Errorf("IntegerScore(%d).IsValid() = %v, want %v", tt.score, got, tt.want)
+		}
+	}
+}
+
+func TestIntegerScore_IsPassing(t *testing.T) {
+	tests := []struct {
+		score IntegerScore
+		want  bool
+	}{
+		{ScoreUnacceptable, false},
+		{ScoreMajorRevisions, false},
+		{ScoreAcceptable, false},
+		{ScoreGood, true},
+		{ScoreExcellent, true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.score.String(), func(t *testing.T) {
+			if got := tt.score.IsPassing(); got != tt.want {
+				t.Errorf("IntegerScore(%d).IsPassing() = %v, want %v", tt.score, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestParseIntegerScore(t *testing.T) {
+	tests := []struct {
+		input int
+		want  IntegerScore
+	}{
+		{-1, ScoreUnacceptable},
+		{0, ScoreUnacceptable},
+		{1, ScoreUnacceptable},
+		{2, ScoreMajorRevisions},
+		{3, ScoreAcceptable},
+		{4, ScoreGood},
+		{5, ScoreExcellent},
+		{6, ScoreExcellent},
+		{100, ScoreExcellent},
+	}
+
+	for _, tt := range tests {
+		if got := ParseIntegerScore(tt.input); got != tt.want {
+			t.Errorf("ParseIntegerScore(%d) = %d, want %d", tt.input, got, tt.want)
+		}
+	}
+}
+
+func TestIntegerScore_Icon(t *testing.T) {
+	// Just verify icons are non-empty
+	for _, score := range AllIntegerScores() {
+		if icon := score.Icon(); icon == "" {
+			t.Errorf("IntegerScore(%d).Icon() should not be empty", score)
+		}
+	}
+}