obey-cli 0.1.0__py3-none-any.whl

obey_cli/_data/demo/repo/src/shift-planner.test.ts

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: Apache-2.0
+import { describe, expect, it } from "vitest";
+import type { NewShift, Person, Shift } from "./generated/api-types.js";
+import { findConflicts, groupByDay, validateNewShift, weeklyHours } from "./shift-planner.js";
+
+const WEEK = new Date("2026-03-02T00:00:00Z");
+
+const ada: Person = { id: "p1", name: "Ada Example", role: "barista" };
+const bo: Person = { id: "p2", name: "Bo Example", role: "baker", maxWeeklyHours: 10 };
+
+function shift(id: string, personId: string, day: number, startHour: number, endHour: number): Shift {
+  const at = (hour: number): string => new Date(Date.UTC(2026, 2, day, hour)).toISOString();
+  return { id, personId, start: at(startHour), end: at(endHour) };
+}
+
+describe("findConflicts", () => {
+  it("reports overlapping shifts for the same person only", () => {
+    const shifts = [
+      shift("a", "p1", 2, 9, 13),
+      shift("b", "p1", 2, 12, 16),
+      shift("c", "p2", 2, 12, 16),
+      shift("d", "p1", 3, 9, 13),
+    ];
+    const conflicts = findConflicts(shifts);
+    expect(conflicts).toHaveLength(1);
+    expect(conflicts[0]?.personId).toBe("p1");
+    expect([conflicts[0]?.first.id, conflicts[0]?.second.id]).toEqual(["a", "b"]);
+  });
+});
+
+describe("weeklyHours and groupByDay", () => {
+  const shifts = [shift("a", "p1", 2, 9, 17), shift("b", "p1", 4, 9, 13), shift("c", "p1", 9, 9, 17)];
+
+  it("sums only the shifts that start in the given week", () => {
+    expect(weeklyHours(shifts, WEEK).get("p1")).toBe(12);
+  });
+
+  it("groups shifts by day and keeps empty days", () => {
+    const days = groupByDay(shifts, WEEK);
+    expect([...days.keys()]).toHaveLength(7);
+    expect(days.get("2026-03-02")?.map((s) => s.id)).toEqual(["a"]);
+    expect(days.get("2026-03-03")).toEqual([]);
+  });
+});
+
+describe("validateNewShift", () => {
+  const existing = [shift("a", "p1", 2, 9, 17)];
+  const candidate = (personId: string, day: number, startHour: number, endHour: number): NewShift => {
+    const { start, end } = shift("new", personId, day, startHour, endHour);
+    return { personId, start, end };
+  };
+
+  it("accepts a shift that fits", () => {
+    expect(validateNewShift(candidate("p1", 3, 9, 17), existing, ada)).toEqual([]);
+  });
+
+  it("explains every rule that is broken", () => {
+    expect(validateNewShift(candidate("p9", 3, 9, 17), existing, undefined)).toEqual(["unknown person: p9"]);
+    expect(validateNewShift(candidate("p1", 3, 17, 9), existing, ada)).toEqual(["a shift must end after it starts"]);
+    expect(validateNewShift(candidate("p1", 2, 12, 20), existing, ada)).toEqual(["Ada Example already has a shift then"]);
+    expect(validateNewShift(candidate("p2", 3, 6, 20), [], bo)).toEqual([
+      "a shift cannot be longer than 12 hours",
+      "Bo Example would exceed 10 hours this week",
+    ]);
+  });
+});

obey_cli/_data/demo/repo/src/shift-planner.ts

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: Apache-2.0
+import {
+  addDays,
+  hoursBetween,
+  parseIsoDateTime,
+  rangesOverlap,
+  startOfWeek,
+  toDayKey,
+  weekDays,
+} from "./date-utils.js";
+import type { NewShift, Person, Shift } from "./generated/api-types.js";
+
+export const MAX_SHIFT_HOURS = 12;
+export const DEFAULT_WEEKLY_LIMIT = 40;
+
+export interface Conflict {
+  personId: string;
+  first: Shift;
+  second: Shift;
+}
+
+function byStart(a: Shift, b: Shift): number {
+  return parseIsoDateTime(a.start).getTime() - parseIsoDateTime(b.start).getTime();
+}
+
+/** Pairs of shifts that overlap for the same person. */
+export function findConflicts(shifts: readonly Shift[]): Conflict[] {
+  const byPerson = new Map<string, Shift[]>();
+  for (const shift of shifts) {
+    byPerson.set(shift.personId, [...(byPerson.get(shift.personId) ?? []), shift]);
+  }
+  const conflicts: Conflict[] = [];
+  for (const [personId, list] of byPerson) {
+    const sorted = [...list].sort(byStart);
+    for (let i = 0; i < sorted.length; i += 1) {
+      for (let j = i + 1; j < sorted.length; j += 1) {
+        const first = sorted[i];
+        const second = sorted[j];
+        if (first && second && overlaps(first, second)) conflicts.push({ personId, first, second });
+      }
+    }
+  }
+  return conflicts;
+}
+
+function overlaps(a: Pick<Shift, "start" | "end">, b: Pick<Shift, "start" | "end">): boolean {
+  return rangesOverlap(
+    parseIsoDateTime(a.start),
+    parseIsoDateTime(a.end),
+    parseIsoDateTime(b.start),
+    parseIsoDateTime(b.end),
+  );
+}
+
+/** Scheduled hours per person id for shifts that start in the week beginning at `weekStart`. */
+export function weeklyHours(shifts: readonly Shift[], weekStart: Date): Map<string, number> {
+  const weekEnd = addDays(weekStart, 7);
+  const totals = new Map<string, number>();
+  for (const shift of shifts) {
+    const start = parseIsoDateTime(shift.start);
+    if (start < weekStart || start >= weekEnd) continue;
+    const hours = hoursBetween(start, parseIsoDateTime(shift.end));
+    totals.set(shift.personId, (totals.get(shift.personId) ?? 0) + hours);
+  }
+  return totals;
+}
+
+/** Shifts grouped by the UTC day they start on, one (possibly empty) entry for each day of the week. */
+export function groupByDay(shifts: readonly Shift[], weekStart: Date): Map<string, Shift[]> {
+  const days = new Map<string, Shift[]>(
+    weekDays(weekStart).map((day): [string, Shift[]] => [toDayKey(day), []]),
+  );
+  for (const shift of [...shifts].sort(byStart)) {
+    days.get(toDayKey(parseIsoDateTime(shift.start)))?.push(shift);
+  }
+  return days;
+}
+
+/** Reasons a new shift cannot be added; an empty list means it is fine. */
+export function validateNewShift(
+  candidate: NewShift,
+  existing: readonly Shift[],
+  person: Person | undefined,
+): string[] {
+  if (!person) return [`unknown person: ${candidate.personId}`];
+  const start = parseIsoDateTime(candidate.start);
+  const end = parseIsoDateTime(candidate.end);
+  if (end <= start) return ["a shift must end after it starts"];
+
+  const errors: string[] = [];
+  const length = hoursBetween(start, end);
+  if (length > MAX_SHIFT_HOURS) errors.push(`a shift cannot be longer than ${MAX_SHIFT_HOURS} hours`);
+
+  const own = existing.filter((shift) => shift.personId === person.id);
+  if (own.some((shift) => overlaps(candidate, shift))) errors.push(`${person.name} already has a shift then`);
+
+  const planned = weeklyHours(own, startOfWeek(start)).get(person.id) ?? 0;
+  const limit = person.maxWeeklyHours ?? DEFAULT_WEEKLY_LIMIT;
+  if (planned + length > limit) errors.push(`${person.name} would exceed ${limit} hours this week`);
+  return errors;
+}

obey_cli/_data/demo/repo/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM"],
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "noFallthroughCasesInSwitch": true,
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "skipLibCheck": true,
+    "types": [],
+    "rootDir": "src",
+    "outDir": "dist",
+    "sourceMap": true
+  },
+  "include": ["src"]
+}

obey_cli/_data/demo/repo/vitest.config.ts

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: Apache-2.0
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["src/**/*.test.ts"],
+  },
+});

obey_cli/_data/demo/runs/meta.json

@@ -0,0 +1,10 @@
+{
+  "agent": "claude-code",
+  "agent_version": "2.1.309",
+  "model": "anthropic/claude-haiku-5.5",
+  "repository": "ts-web (obey demo repository)",
+  "dates": "2026-10-23 to 2026-10-24",
+  "runs": 322,
+  "cost_usd": 3.1117,
+  "compare_with": "baseline"
+}

obey_cli/_data/schemas/obey-config-v1.json

@@ -0,0 +1,116 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/B0yko/obey/schemas/obey-config-v1.json",
+  "title": "obey.yaml",
+  "type": "object",
+  "required": ["version", "rules"],
+  "additionalProperties": false,
+  "$defs": {
+    "globs": {"type": "array", "items": {"type": "string", "minLength": 1}},
+    "regex": {"type": "string", "minLength": 1},
+    "checker": {
+      "type": "object",
+      "required": ["type", "params"],
+      "additionalProperties": false,
+      "properties": {
+        "type": {"enum": ["command_forbidden", "command_required", "path_forbidden", "path_required_with",
+                          "dependency_unchanged", "content_forbidden_added", "content_required_added",
+                          "commit_message", "no_commit", "no_push", "file_naming", "final_message"]},
+        "params": {"type": "object"}
+      },
+      "allOf": [
+        {"if": {"properties": {"type": {"const": "command_forbidden"}}},
+         "then": {"properties": {"params": {"required": ["patterns"], "additionalProperties": false, "properties": {
+           "patterns": {"type": "array", "minItems": 1, "items": {"$ref": "#/$defs/regex"}},
+           "preferred": {"type": "string"},
+           "preferred_patterns": {"type": "array", "items": {"$ref": "#/$defs/regex"}},
+           "manual_edit_paths": {"$ref": "#/$defs/globs"}}}}}},
+        {"if": {"properties": {"type": {"const": "command_required"}}},
+         "then": {"properties": {"params": {"required": ["pattern"], "additionalProperties": false, "properties": {
+           "pattern": {"$ref": "#/$defs/regex"}, "edit_globs": {"$ref": "#/$defs/globs"},
+           "require_success": {"type": "boolean"}}}}}},
+        {"if": {"properties": {"type": {"const": "path_forbidden"}}},
+         "then": {"properties": {"params": {"required": ["globs"], "additionalProperties": false, "properties": {
+           "globs": {"$ref": "#/$defs/globs", "minItems": 1}, "existing_only": {"type": "boolean"},
+           "allow_via": {"type": "array", "items": {"$ref": "#/$defs/regex"}}}}}}},
+        {"if": {"properties": {"type": {"const": "path_required_with"}}},
+         "then": {"properties": {"params": {"required": ["when", "require"], "additionalProperties": false,
+           "properties": {"when": {"$ref": "#/$defs/globs"}, "require": {"$ref": "#/$defs/globs"}}}}}},
+        {"if": {"properties": {"type": {"const": "dependency_unchanged"}}},
+         "then": {"properties": {"params": {"additionalProperties": false, "properties": {
+           "manifests": {"$ref": "#/$defs/globs"}, "allow": {"type": "array", "items": {"type": "string"}}}}}}},
+        {"if": {"properties": {"type": {"const": "content_forbidden_added"}}},
+         "then": {"properties": {"params": {"required": ["regex", "globs"], "additionalProperties": false,
+           "properties": {"regex": {"$ref": "#/$defs/regex"}, "globs": {"$ref": "#/$defs/globs"}}}}}},
+        {"if": {"properties": {"type": {"const": "content_required_added"}}},
+         "then": {"properties": {"params": {"required": ["regex", "globs"], "additionalProperties": false,
+           "properties": {"regex": {"$ref": "#/$defs/regex"}, "globs": {"$ref": "#/$defs/globs"},
+                          "scope": {"const": "new_files"}, "first_lines": {"type": "integer", "minimum": 1}}}}}},
+        {"if": {"properties": {"type": {"const": "commit_message"}}},
+         "then": {"properties": {"params": {"required": ["regex"], "additionalProperties": false,
+           "properties": {"regex": {"$ref": "#/$defs/regex"}}}}}},
+        {"if": {"properties": {"type": {"enum": ["no_commit", "no_push"]}}},
+         "then": {"properties": {"params": {"maxProperties": 0}}}},
+        {"if": {"properties": {"type": {"const": "file_naming"}}},
+         "then": {"properties": {"params": {"required": ["globs", "pattern"], "additionalProperties": false,
+           "properties": {"globs": {"$ref": "#/$defs/globs"}, "pattern": {"$ref": "#/$defs/regex"}}}}}},
+        {"if": {"properties": {"type": {"const": "final_message"}}},
+         "then": {"properties": {"params": {"additionalProperties": false, "minProperties": 1, "maxProperties": 1,
+           "properties": {"required": {"$ref": "#/$defs/regex"}, "forbidden": {"$ref": "#/$defs/regex"}}}}}}
+      ]
+    },
+    "probe": {
+      "type": "object",
+      "required": ["id", "template", "instruction"],
+      "additionalProperties": false,
+      "properties": {
+        "id": {"type": "string"},
+        "template": {"type": "string"},
+        "instruction": {"type": "string", "minLength": 1},
+        "setup_patch": {"type": ["string", "null"]},
+        "domain": {"type": ["string", "null"]},
+        "control": {"type": "boolean"}
+      }
+    }
+  },
+  "properties": {
+    "version": {"const": 1},
+    "generated_by": {"type": "string"},
+    "sources": {"type": "array", "items": {"type": "object", "required": ["file", "sha256"],
+      "additionalProperties": false, "properties": {"file": {"type": "string"},
+      "sha256": {"type": "string", "pattern": "^[0-9a-f]{64}$"}, "kind": {"type": "string"},
+      "scope": {"$ref": "#/$defs/globs"}, "loaded_by": {"type": "array", "items": {"type": "string"}}}}},
+    "sandbox": {"type": "object", "additionalProperties": false, "properties": {
+      "image": {"type": ["string", "null"]},
+      "allow_hosts": {"type": "array", "items": {"type": "string"}},
+      "timeout_s": {"type": "integer", "minimum": 30},
+      "cpus": {"type": "string"}, "memory": {"type": "string"}}},
+    "agents": {"type": "array", "items": {"type": "object", "required": ["agent"], "additionalProperties": false,
+      "properties": {"agent": {"type": "string"}, "model": {"type": "string"}}}},
+    "rules": {"type": "array", "items": {
+      "type": "object",
+      "required": ["id", "text", "source", "status", "checker"],
+      "additionalProperties": false,
+      "properties": {
+        "id": {"type": "string", "pattern": "^[a-z0-9][a-z0-9-]*$"},
+        "text": {"type": "string", "minLength": 1},
+        "source": {"type": "object", "required": ["file", "lines"], "additionalProperties": false, "properties": {
+          "file": {"type": "string"}, "lines": {"type": "array", "items": {"type": "integer", "minimum": 1},
+          "minItems": 2, "maxItems": 2}}},
+        "scope": {"type": "object", "additionalProperties": false, "properties": {
+          "paths": {"$ref": "#/$defs/globs"}, "agents": {"type": ["array", "null"], "items": {"type": "string"}}}},
+        "checker": {"oneOf": [{"type": "null"}, {"$ref": "#/$defs/checker"}]},
+        "status": {"enum": ["active", "proposed", "uncheckable", "disabled"]},
+        "reason": {"type": ["string", "null"]},
+        "origin": {"enum": ["pattern", "llm", "user"]},
+        "probes": {"type": "array", "items": {"$ref": "#/$defs/probe"}}
+      },
+      "allOf": [
+        {"if": {"properties": {"status": {"enum": ["active", "proposed"]}}},
+         "then": {"properties": {"checker": {"$ref": "#/$defs/checker"}}}},
+        {"if": {"properties": {"status": {"enum": ["uncheckable", "disabled"]}}},
+         "then": {"required": ["reason"], "properties": {"reason": {"type": "string", "minLength": 1}}}}
+      ]
+    }}
+  }
+}

obey_cli/_data/schemas/report-v1.json

@@ -0,0 +1,55 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/B0yko/obey/schemas/report-v1.json",
+  "title": "obey run report",
+  "type": "object",
+  "required": ["schema", "obey_version", "generated_at", "agents", "summary", "rules", "scores", "pooled", "suggestions",
+               "cost", "compare"],
+  "additionalProperties": false,
+  "$defs": {
+    "fraction": {"type": ["number", "null"], "minimum": 0, "maximum": 1},
+    "pooled": {
+      "type": "object",
+      "required": ["obeyed", "exercised", "runs", "compliance", "ci_low", "ci_high", "blocked_runs", "evasions",
+                   "evasion_rate"],
+      "properties": {
+        "obeyed": {"type": "integer", "minimum": 0}, "exercised": {"type": "integer", "minimum": 0},
+        "runs": {"type": "integer", "minimum": 0}, "compliance": {"$ref": "#/$defs/fraction"},
+        "ci_low": {"$ref": "#/$defs/fraction"}, "ci_high": {"$ref": "#/$defs/fraction"},
+        "blocked_runs": {"type": "integer", "minimum": 0}, "evasions": {"type": "integer", "minimum": 0},
+        "evasion_rate": {"$ref": "#/$defs/fraction"}
+      }
+    }
+  },
+  "properties": {
+    "schema": {"const": "obey-report-v1"},
+    "obey_version": {"type": "string"},
+    "generated_at": {"type": "string"},
+    "repository": {"type": "string"},
+    "hardware": {"type": ["string", "null"]},
+    "agents": {"type": "array", "items": {"type": "object", "required": ["agent"],
+               "properties": {"agent": {"type": "string"}, "version": {"type": ["string", "null"]},
+                              "model": {"type": ["string", "null"]}}}},
+    "summary": {"type": "array", "items": {"type": "string"}},
+    "rules": {"type": "array", "items": {"type": "object", "required": ["id", "text", "source", "checker", "status"],
+              "properties": {"id": {"type": "string"}, "text": {"type": "string"}, "source": {"type": "object"},
+                             "checker": {"type": "string"},
+                             "status": {"enum": ["active", "proposed", "uncheckable", "disabled"]}}}},
+    "scores": {"type": "array", "items": {"type": "object",
+               "required": ["rule_id", "agent", "arm", "runs", "exercised", "obeyed", "violated", "compliance",
+                            "ci_low", "ci_high", "exercised_share", "blocked_runs", "evasions", "evasion_rate",
+                            "violation_example", "errors"],
+               "properties": {"arm": {"enum": ["rule", "baseline", "enforced"]},
+                              "compliance": {"$ref": "#/$defs/fraction"}, "ci_low": {"$ref": "#/$defs/fraction"},
+                              "ci_high": {"$ref": "#/$defs/fraction"},
+                              "exercised_share": {"$ref": "#/$defs/fraction"},
+                              "evasion_rate": {"$ref": "#/$defs/fraction"}}}},
+    "pooled": {"type": "object", "additionalProperties": {"type": "object",
+               "additionalProperties": {"$ref": "#/$defs/pooled"}}},
+    "suggestions": {"type": "array", "items": {"type": "object", "required": ["rule_id", "kind", "text"]}},
+    "cost": {"type": "object", "required": ["total_usd", "runs", "per_run_usd"]},
+    "compare": {"type": ["object", "null"], "required": ["rows", "before", "after"],
+                "properties": {"rows": {"type": "array"}, "before": {"$ref": "#/$defs/pooled"},
+                               "after": {"$ref": "#/$defs/pooled"}}}
+  }
+}

obey_cli/_data/schemas/survey-record-v1.json

@@ -0,0 +1,30 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/B0yko/obey/schemas/survey-record-v1.json",
+  "title": "obey survey sample record",
+  "description": "One surveyed repository. URLs, SHAs, licence ids and derived booleans only; never file contents.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["repo", "url", "commit_sha", "path", "blob_sha", "license_spdx", "stars", "default_branch",
+               "size_slice", "tree_truncated", "has_claude_md", "has_gemini_md", "has_cursor_rules",
+               "has_copilot_instructions", "claude_settings_hooks", "gemini_settings_hooks", "enforcement"],
+  "properties": {
+    "repo": {"type": "string", "pattern": "^[^/]+/[^/]+$"},
+    "url": {"type": "string", "format": "uri"},
+    "commit_sha": {"type": "string", "pattern": "^[0-9a-f]{40}$"},
+    "path": {"const": "AGENTS.md"},
+    "blob_sha": {"type": "string"},
+    "license_spdx": {"type": ["string", "null"]},
+    "stars": {"type": "integer", "minimum": 0},
+    "default_branch": {"type": "string"},
+    "size_slice": {"type": "string"},
+    "tree_truncated": {"type": "boolean"},
+    "has_claude_md": {"type": "boolean"},
+    "has_gemini_md": {"type": "boolean"},
+    "has_cursor_rules": {"type": "boolean"},
+    "has_copilot_instructions": {"type": "boolean"},
+    "claude_settings_hooks": {"type": "boolean"},
+    "gemini_settings_hooks": {"type": "boolean"},
+    "enforcement": {"type": "object", "additionalProperties": {"type": "boolean"}}
+  }
+}

obey_cli/checkers/__init__.py

@@ -0,0 +1,30 @@
+"""Deterministic checkers: one verdict per rule per run, with evidence.
+
+The logic lives in the stdlib-only rule engine (`obey_cli.enforce.engine.obey_engine`), which `obey enforce` also
+vendors into generated hooks, so what a hook blocks is exactly what a checker measures.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from typing import Any
+
+from obey_cli.enforce.engine import obey_engine as engine
+
+TYPES = tuple(engine.CHECKS)
+
+
+@dataclass
+class Verdict:
+    verdict: str  # obeyed | violated | not_exercised
+    evidence: list[dict[str, Any]] = field(default_factory=list)
+
+
+def check(rule: Mapping[str, Any], run: Mapping[str, Any]) -> Verdict:
+    """Verdict of `rule` (a checker {"type", "params"} or a rule holding one) on a normalised run record."""
+    result = engine.check(dict(rule), dict(run))
+    return Verdict(verdict=str(result["verdict"]), evidence=list(result.get("evidence") or []))
+
+
+__all__ = ["TYPES", "Verdict", "check", "engine"]

obey_cli/checkers/samples.py

@@ -0,0 +1,95 @@
+"""Decide labelled extraction samples with the engine (used by eval/run_eval.py to score extracted parameters).
+
+A sample is flagged when the extracted checker reports a violation for a minimal run built from it; see
+fixtures/extraction for the sample formats.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from obey_cli.enforce.engine import obey_engine as engine
+
+
+def _empty() -> dict[str, Any]:
+    return {"events": [], "diff": "", "base_files": [], "commits": [], "pushed_refs": [], "final_message": ""}
+
+
+def _modified(path: str, line: str = "x = 1") -> str:
+    return f"diff --git a/{path} b/{path}\n--- a/{path}\n+++ b/{path}\n@@ -1,0 +1,1 @@\n+{line}\n"
+
+
+def _split(sample: str) -> tuple[str, str]:
+    path, _, line = sample.partition(": ")
+    return path.strip(), line
+
+
+def run_for(checker: dict[str, Any], sample: Any) -> dict[str, Any]:
+    kind = checker["type"]
+    run = _empty()
+    if kind in ("command_forbidden", "no_commit", "no_push"):
+        run["events"] = [{"seq": 0, "type": "shell", "command": str(sample), "exit_code": 0}]
+    elif kind == "command_required":
+        globs = checker["params"].get("edit_globs") or ["**"]
+        path = "src/app.py"
+        for candidate in ("src/app.py", "app/main.py", "src/index.ts", "main.go", "src/lib.rs", "docs/index.md"):
+            if engine.glob_match(globs, candidate):
+                path = candidate
+                break
+        else:
+            path = globs[0].replace("**/", "").replace("**", "x").replace("*", "x")
+        run["events"] = [
+            {"seq": 0, "type": "edit", "path": path},
+            {"seq": 1, "type": "shell", "command": str(sample), "exit_code": 0},
+        ]
+        run["diff"] = _modified(path)
+    elif kind == "path_forbidden":
+        run["events"] = [{"seq": 0, "type": "write", "path": str(sample)}]
+        run["base_files"] = [str(sample)]
+    elif kind == "path_required_with":
+        files = sample if isinstance(sample, list) else [sample]
+        run["diff"] = "".join(_modified(str(f)) for f in files)
+    elif kind == "dependency_unchanged":
+        text = str(sample)
+        if ": +" in text:
+            path, _, name = text.partition(": +")
+            path = path.strip()
+            base = path.rsplit("/", 1)[-1]
+            if base == "package.json":
+                line = f'    "{name.strip()}": "^1.0.0",'
+            elif base == "go.mod":
+                line = f"\t{name.strip()} v1.0.0"
+            elif base == "Cargo.toml":
+                line = f'{name.strip()} = "1.0"'
+            elif base.startswith("requirements"):
+                line = f"{name.strip()}>=1.0"
+            else:
+                line = f'    "{name.strip()}>=1.0",'
+            run["diff"] = _modified(path, line)
+        else:
+            run["events"] = [{"seq": 0, "type": "shell", "command": text, "exit_code": 0}]
+    elif kind == "content_forbidden_added":
+        path, line = _split(str(sample))
+        run["diff"] = _modified(path, line)
+    elif kind == "content_required_added":
+        path, line = _split(str(sample))
+        run["diff"] = engine.new_file_diff(path, line + "\n")
+    elif kind == "commit_message":
+        run["commits"] = [{"sha": "0" * 40, "message": str(sample), "files": []}]
+    elif kind == "file_naming":
+        run["diff"] = engine.new_file_diff(str(sample), "x\n")
+    elif kind == "final_message":
+        run["final_message"] = str(sample)
+    else:
+        raise ValueError(f"unknown checker type {kind}")
+    return run
+
+
+def classify_sample(checker: dict[str, Any], sample: Any) -> bool:
+    """True when the sample breaks the rule according to the extracted checker."""
+    try:
+        verdict = engine.check(checker, run_for(checker, sample))
+    except (KeyError, ValueError, TypeError, json.JSONDecodeError):
+        return False
+    return bool(verdict["verdict"] == "violated")