claude-dev-env 1.95.0 → 2.0.1

package/_shared/pr-loop/scripts/code_rules_gate_parts/tests/conftest.py

@@ -0,0 +1,14 @@
+"""Put the pr-loop scripts directory on sys.path for the parts test suite.
+
+Importing this conftest inserts the ``_shared/pr-loop/scripts`` directory (this
+file's parent's parent's parent) at the front of sys.path so the parts modules
+resolve ``pr_loop_shared_constants`` and ``terminology_sweep`` with every import
+kept at module top.
+"""
+
+import sys
+from pathlib import Path
+
+_scripts_directory = str(Path(__file__).resolve().parents[2])
+if _scripts_directory not in sys.path:
+    sys.path.insert(0, _scripts_directory)

package/_shared/pr-loop/scripts/code_rules_gate_parts/tests/test_added_line_maps.py

@@ -0,0 +1,118 @@
+"""Behavioral tests for the added_line_maps parts module."""
+
+import subprocess
+from pathlib import Path
+
+from code_rules_gate_parts import added_line_maps, git_file_sets
+
+
+def _run(repository_root: Path, *arguments: str) -> None:
+    subprocess.run(
+        ["git", *arguments],
+        cwd=str(repository_root),
+        check=True,
+        capture_output=True,
+        env=git_file_sets.repository_environment(),
+    )
+
+
+def _base_repository(repository_root: Path) -> None:
+    _run(repository_root, "init", "--initial-branch=main")
+    _run(repository_root, "config", "user.email", "test@example.com")
+    _run(repository_root, "config", "user.name", "Test")
+    _run(repository_root, "config", "commit.gpgsign", "false")
+    disabled_hooks = repository_root / "disabled-git-hooks"
+    disabled_hooks.mkdir()
+    _run(repository_root, "config", "core.hooksPath", str(disabled_hooks))
+    (repository_root / "base.py").write_text("a = 1\nb = 2\n", encoding="utf-8")
+    _run(repository_root, "add", "-A")
+    _run(repository_root, "commit", "-m", "base")
+
+
+def _head_sha(repository_root: Path) -> str:
+    return subprocess.run(
+        ["git", "rev-parse", "HEAD"],
+        cwd=str(repository_root),
+        check=True,
+        capture_output=True,
+        text=True,
+        env=git_file_sets.repository_environment(),
+    ).stdout.strip()
+
+
+def test_whole_file_line_set_covers_every_line(tmp_path: Path) -> None:
+    module_path = tmp_path / "three.py"
+    module_path.write_text("a\nb\nc\n", encoding="utf-8")
+    assert added_line_maps.whole_file_line_set(module_path) == {1, 2, 3}
+
+
+def test_is_file_new_at_base_distinguishes_added_and_existing(tmp_path: Path) -> None:
+    repository_root = tmp_path / "repo"
+    repository_root.mkdir()
+    _base_repository(repository_root)
+    base_sha = _head_sha(repository_root)
+    (repository_root / "fresh.py").write_text("x = 1\n", encoding="utf-8")
+    _run(repository_root, "add", "-A")
+    _run(repository_root, "commit", "-m", "add fresh")
+
+    assert added_line_maps.is_file_new_at_base(repository_root, base_sha, "fresh.py")
+    assert not added_line_maps.is_file_new_at_base(repository_root, base_sha, "base.py")
+
+
+def test_added_lines_for_file_reports_new_lines(tmp_path: Path) -> None:
+    repository_root = tmp_path / "repo"
+    repository_root.mkdir()
+    _base_repository(repository_root)
+    base_sha = _head_sha(repository_root)
+    (repository_root / "base.py").write_text("a = 1\nb = 2\nc = 3\n", encoding="utf-8")
+    _run(repository_root, "add", "-A")
+    _run(repository_root, "commit", "-m", "extend")
+
+    added = added_line_maps.added_lines_for_file(repository_root, base_sha, "base.py")
+
+    assert added == {3}
+
+
+def test_renamed_file_source_map_since_maps_destination_to_source(tmp_path: Path) -> None:
+    repository_root = tmp_path / "repo"
+    repository_root.mkdir()
+    _base_repository(repository_root)
+    base_sha = _head_sha(repository_root)
+    _run(repository_root, "mv", "base.py", "moved.py")
+    _run(repository_root, "commit", "-m", "rename")
+
+    rename_map = added_line_maps.renamed_file_source_map_since(repository_root, base_sha)
+
+    assert rename_map == {"moved.py": "base.py"}
+
+
+def test_added_lines_by_file_marks_new_file_whole(tmp_path: Path) -> None:
+    repository_root = tmp_path / "repo"
+    repository_root.mkdir()
+    _base_repository(repository_root)
+    base_sha = _head_sha(repository_root)
+    fresh = repository_root / "fresh.py"
+    fresh.write_text("x = 1\ny = 2\n", encoding="utf-8")
+    _run(repository_root, "add", "-A")
+    _run(repository_root, "commit", "-m", "add fresh")
+
+    added_by_path = added_line_maps.added_lines_by_file(repository_root, base_sha, [fresh])
+
+    assert added_by_path[fresh.resolve()] == {1, 2}
+
+
+def test_added_lines_for_renamed_file_reports_only_new_lines(tmp_path: Path) -> None:
+    repository_root = tmp_path / "repo"
+    repository_root.mkdir()
+    _base_repository(repository_root)
+    base_sha = _head_sha(repository_root)
+    _run(repository_root, "mv", "base.py", "moved.py")
+    (repository_root / "moved.py").write_text("a = 1\nb = 2\nc = 3\n", encoding="utf-8")
+    _run(repository_root, "add", "-A")
+    _run(repository_root, "commit", "-m", "rename and extend")
+
+    added = added_line_maps.added_lines_for_renamed_file(
+        repository_root, base_sha, "base.py", "moved.py"
+    )
+
+    assert added == {3}

package/_shared/pr-loop/scripts/code_rules_gate_parts/tests/test_enforcer_loading.py

@@ -0,0 +1,17 @@
+"""Behavioral tests for the enforcer_loading parts module."""
+
+from pathlib import Path
+
+from code_rules_gate_parts import enforcer_loading
+
+
+def test_resolve_claude_dev_env_root_finds_enforcer_bearing_root() -> None:
+    resolved_root = enforcer_loading.resolve_claude_dev_env_root(Path(__file__))
+    assert (resolved_root / "hooks" / "blocking" / "code_rules_enforcer.py").is_file()
+
+
+def test_load_validate_content_returns_callable_passing_a_clean_module() -> None:
+    validate_content = enforcer_loading.load_validate_content()
+    clean_module = '"""Clean module."""\n\n\ndef ping() -> str:\n    return "pong"\n'
+    issues = validate_content(clean_module, "sample.py", "")
+    assert issues == []

package/_shared/pr-loop/scripts/code_rules_gate_parts/tests/test_gate_arguments.py

@@ -0,0 +1,29 @@
+"""Behavioral tests for the gate_arguments parts module."""
+
+from pathlib import Path
+
+from code_rules_gate_parts import gate_arguments
+
+
+def test_parse_arguments_reads_staged_base_and_repo_root() -> None:
+    arguments = gate_arguments.parse_arguments(
+        ["--staged", "--base", "main", "--repo-root", "/tmp/repo"]
+    )
+    assert arguments.staged is True
+    assert arguments.base == "main"
+    assert arguments.repo_root == Path("/tmp/repo")
+
+
+def test_parse_arguments_collects_only_under_and_paths() -> None:
+    arguments = gate_arguments.parse_arguments(
+        ["--only-under", "pkg", "--only-under", "lib", "a.py", "b.py"]
+    )
+    assert arguments.only_under == ["pkg", "lib"]
+    assert arguments.paths == [Path("a.py"), Path("b.py")]
+
+
+def test_parse_arguments_defaults_base_to_origin_main() -> None:
+    arguments = gate_arguments.parse_arguments([])
+    assert arguments.base == "origin/main"
+    assert arguments.staged is False
+    assert arguments.only_under == []

package/_shared/pr-loop/scripts/code_rules_gate_parts/tests/test_gate_running.py

@@ -0,0 +1,99 @@
+"""Behavioral tests for the gate_running parts module."""
+
+from pathlib import Path
+
+import pytest
+from code_rules_gate_parts import gate_running
+
+
+def _clean_validate(_content: str, _path: str, _prior: str = "", **_kwargs: object) -> list[str]:
+    return []
+
+
+def _dirty_validate(_content: str, _path: str, _prior: str = "", **_kwargs: object) -> list[str]:
+    return ["Line 1: bad"]
+
+
+def _install_eligibility_walk_counter(monkeypatch: pytest.MonkeyPatch) -> list[int]:
+    """Wrap ``_eligible_resolved_paths`` to tally how many walks a run makes."""
+    walk_count_holder = [0]
+    real_eligible_resolved_paths = gate_running._eligible_resolved_paths
+
+    def counting_eligible_resolved_paths(
+        all_file_paths: list[Path],
+        repository_root: Path,
+        should_read_staged_content: bool,
+    ) -> list[Path]:
+        walk_count_holder[0] += 1
+        return real_eligible_resolved_paths(
+            all_file_paths, repository_root, should_read_staged_content
+        )
+
+    monkeypatch.setattr(
+        gate_running, "_eligible_resolved_paths", counting_eligible_resolved_paths
+    )
+    return walk_count_holder
+
+
+def test_run_gate_resolves_eligible_paths_once_per_run(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """One ``run_gate`` call walks the eligible file set exactly once.
+
+    Deriving the inspected-file count from a second walk of the file set would
+    re-run the eligibility probe on every candidate — in staged mode a wasted
+    ``git cat-file -e`` subprocess per file. Counting the walks proves the set
+    is resolved a single time.
+    """
+    first_module = tmp_path / "first_module.py"
+    second_module = tmp_path / "second_module.py"
+    first_module.write_text("first_count = 1\n", encoding="utf-8")
+    second_module.write_text("second_count = 2\n", encoding="utf-8")
+
+    walk_count_holder = _install_eligibility_walk_counter(monkeypatch)
+    gate_running.run_gate(
+        _clean_validate,
+        [first_module, second_module],
+        tmp_path,
+        all_added_lines_by_path=None,
+    )
+
+    assert walk_count_holder[0] == 1
+
+
+def test_run_gate_reports_inspected_count_for_clean_file(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    module_path = tmp_path / "clean.py"
+    module_path.write_text("value = 1\n", encoding="utf-8")
+
+    exit_code = gate_running.run_gate(
+        _clean_validate, [module_path], tmp_path, all_added_lines_by_path=None
+    )
+
+    captured = capsys.readouterr()
+    assert exit_code == 0
+    assert "inspected 1 file(s)" in captured.err
+
+
+def test_run_gate_blocks_when_validate_reports_issue(tmp_path: Path) -> None:
+    module_path = tmp_path / "dirty.py"
+    module_path.write_text("value = 1\n", encoding="utf-8")
+
+    exit_code = gate_running.run_gate(
+        _dirty_validate, [module_path], tmp_path, all_added_lines_by_path=None
+    )
+
+    assert exit_code == 1
+
+
+def test_print_violation_section_groups_by_relative_path(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    module_path = (tmp_path / "module.py").resolve()
+
+    gate_running.print_violation_section("HEADER", {module_path: ["Line 1: issue"]}, tmp_path)
+
+    captured = capsys.readouterr()
+    assert "HEADER" in captured.err
+    assert "Line 1: issue" in captured.err

package/_shared/pr-loop/scripts/code_rules_gate_parts/tests/test_git_blob_readers.py

@@ -0,0 +1,69 @@
+"""Behavioral tests for the git_blob_readers parts module."""
+
+import subprocess
+from pathlib import Path
+
+from code_rules_gate_parts import git_blob_readers, git_file_sets
+
+
+def _run(repository_root: Path, *arguments: str) -> None:
+    subprocess.run(
+        ["git", *arguments],
+        cwd=str(repository_root),
+        check=True,
+        capture_output=True,
+        env=git_file_sets.repository_environment(),
+    )
+
+
+def _init_repository(repository_root: Path) -> None:
+    _run(repository_root, "init", "--initial-branch=main")
+    _run(repository_root, "config", "user.email", "test@example.com")
+    _run(repository_root, "config", "user.name", "Test")
+    _run(repository_root, "config", "commit.gpgsign", "false")
+    disabled_hooks = repository_root / "disabled-git-hooks"
+    disabled_hooks.mkdir()
+    _run(repository_root, "config", "core.hooksPath", str(disabled_hooks))
+    (repository_root / "seed.txt").write_text("seed\n", encoding="utf-8")
+    _run(repository_root, "add", "-A")
+    _run(repository_root, "commit", "-m", "seed")
+
+
+def test_read_prior_committed_content_returns_head_blob(tmp_path: Path) -> None:
+    repository_root = tmp_path / "repo"
+    repository_root.mkdir()
+    _init_repository(repository_root)
+    (repository_root / "tracked.py").write_text("value = 1\n", encoding="utf-8")
+    _run(repository_root, "add", "tracked.py")
+    _run(repository_root, "commit", "-m", "add tracked")
+
+    content = git_blob_readers.read_prior_committed_content(repository_root, "tracked.py")
+
+    assert content == "value = 1\n"
+
+
+def test_read_prior_committed_content_returns_empty_for_untracked(tmp_path: Path) -> None:
+    repository_root = tmp_path / "repo"
+    repository_root.mkdir()
+    _init_repository(repository_root)
+
+    assert git_blob_readers.read_prior_committed_content(repository_root, "absent.py") == ""
+
+
+def test_read_staged_content_returns_none_when_not_staged(tmp_path: Path) -> None:
+    repository_root = tmp_path / "repo"
+    repository_root.mkdir()
+    _init_repository(repository_root)
+
+    assert git_blob_readers.read_staged_content(repository_root, "absent.py") is None
+
+
+def test_staged_blob_exists_reflects_index_presence(tmp_path: Path) -> None:
+    repository_root = tmp_path / "repo"
+    repository_root.mkdir()
+    _init_repository(repository_root)
+    (repository_root / "staged.py").write_text("value = 2\n", encoding="utf-8")
+    _run(repository_root, "add", "staged.py")
+
+    assert git_blob_readers.staged_blob_exists(repository_root, "staged.py")
+    assert not git_blob_readers.staged_blob_exists(repository_root, "absent.py")

package/_shared/pr-loop/scripts/code_rules_gate_parts/tests/test_git_file_sets.py

@@ -0,0 +1,137 @@
+"""Behavioral tests for the git_file_sets parts module."""
+
+import subprocess
+from pathlib import Path
+
+from code_rules_gate_parts import git_file_sets
+
+
+def _init_repository(repository_root: Path) -> None:
+    def run(*arguments: str) -> None:
+        subprocess.run(
+            ["git", *arguments],
+            cwd=str(repository_root),
+            check=True,
+            capture_output=True,
+            env=git_file_sets.repository_environment(),
+        )
+
+    run("init", "--initial-branch=main")
+    run("config", "user.email", "test@example.com")
+    run("config", "user.name", "Test")
+    run("config", "commit.gpgsign", "false")
+    (repository_root / "seed.txt").write_text("seed\n", encoding="utf-8")
+    run("add", "-A")
+    run("commit", "-m", "seed")
+
+
+def test_paths_from_git_untracked_lists_only_untracked(tmp_path: Path) -> None:
+    repository_root = tmp_path / "repo"
+    repository_root.mkdir()
+    _init_repository(repository_root)
+    (repository_root / "fresh.py").write_text("value = 1\n", encoding="utf-8")
+
+    resolved_paths = git_file_sets.paths_from_git_untracked(repository_root)
+
+    resolved_names = {each_path.name for each_path in resolved_paths}
+    assert "fresh.py" in resolved_names
+    assert "seed.txt" not in resolved_names
+
+
+def test_paths_from_git_staged_lists_the_staged_file(tmp_path: Path) -> None:
+    repository_root = tmp_path / "repo"
+    repository_root.mkdir()
+    _init_repository(repository_root)
+    (repository_root / "staged_module.py").write_text("value = 2\n", encoding="utf-8")
+    subprocess.run(
+        ["git", "add", "staged_module.py"],
+        cwd=str(repository_root),
+        check=True,
+        capture_output=True,
+        env=git_file_sets.repository_environment(),
+    )
+
+    resolved_names = {
+        each_path.name for each_path in git_file_sets.paths_from_git_staged(repository_root)
+    }
+
+    assert "staged_module.py" in resolved_names
+
+
+def test_filter_paths_under_prefixes_keeps_only_matching_prefix(tmp_path: Path) -> None:
+    kept = tmp_path / "keep" / "module.py"
+    dropped = tmp_path / "other" / "module.py"
+    kept.parent.mkdir(parents=True)
+    dropped.parent.mkdir(parents=True)
+    kept.write_text("value = 3\n", encoding="utf-8")
+    dropped.write_text("value = 4\n", encoding="utf-8")
+
+    filtered = git_file_sets.filter_paths_under_prefixes([kept, dropped], tmp_path, ["keep"])
+
+    assert filtered == [kept]
+
+
+def _staged_repository_with(repository_root: Path, filename: str, content: str) -> None:
+    _init_repository(repository_root)
+    (repository_root / filename).write_text(content, encoding="utf-8")
+    subprocess.run(
+        ["git", "add", filename],
+        cwd=str(repository_root),
+        check=True,
+        capture_output=True,
+        env=git_file_sets.repository_environment(),
+    )
+
+
+def test_resolve_merge_base_of_head_with_itself_is_head_sha(tmp_path: Path) -> None:
+    repository_root = tmp_path / "repo"
+    repository_root.mkdir()
+    _init_repository(repository_root)
+
+    merge_base = git_file_sets.resolve_merge_base(repository_root, "HEAD")
+
+    head_sha = subprocess.run(
+        ["git", "rev-parse", "HEAD"],
+        cwd=str(repository_root),
+        check=True,
+        capture_output=True,
+        text=True,
+        env=git_file_sets.repository_environment(),
+    ).stdout.strip()
+    assert merge_base == head_sha
+
+
+def test_paths_from_git_diff_is_empty_when_head_matches_base(tmp_path: Path) -> None:
+    repository_root = tmp_path / "repo"
+    repository_root.mkdir()
+    _init_repository(repository_root)
+
+    changed_paths = git_file_sets.paths_from_git_diff(repository_root, "HEAD")
+
+    assert changed_paths == []
+
+
+def test_is_staged_file_newly_added_true_for_new_staged_file(tmp_path: Path) -> None:
+    repository_root = tmp_path / "repo"
+    repository_root.mkdir()
+    _staged_repository_with(repository_root, "added.py", "value = 5\n")
+
+    assert git_file_sets.is_staged_file_newly_added(repository_root, "added.py")
+
+
+def test_staged_file_line_count_reports_blob_line_count(tmp_path: Path) -> None:
+    repository_root = tmp_path / "repo"
+    repository_root.mkdir()
+    _staged_repository_with(repository_root, "three.py", "a = 1\nb = 2\nc = 3\n")
+
+    assert git_file_sets.staged_file_line_count(repository_root, "three.py") == 3
+
+
+def test_staged_unified_diff_text_carries_hunk_header(tmp_path: Path) -> None:
+    repository_root = tmp_path / "repo"
+    repository_root.mkdir()
+    _staged_repository_with(repository_root, "hunk.py", "a = 1\n")
+
+    diff_text = git_file_sets.staged_unified_diff_text(repository_root, "hunk.py")
+
+    assert "@@" in diff_text

package/_shared/pr-loop/scripts/code_rules_gate_parts/tests/test_staged_test_running.py

@@ -0,0 +1,116 @@
+"""Behavioral tests for the staged_test_running parts module."""
+
+import subprocess
+from pathlib import Path
+
+from code_rules_gate_parts import git_file_sets, staged_test_running
+
+
+def _git(repository_root: Path, *arguments: str) -> None:
+    subprocess.run(
+        ["git", *arguments],
+        cwd=str(repository_root),
+        check=True,
+        capture_output=True,
+        env=git_file_sets.repository_environment(),
+    )
+
+
+def _init_repository(repository_root: Path) -> None:
+    _git(repository_root, "init", "--initial-branch=main")
+    _git(repository_root, "config", "user.email", "test@example.com")
+    _git(repository_root, "config", "user.name", "Test")
+    _git(repository_root, "config", "commit.gpgsign", "false")
+    (repository_root / "seed.txt").write_text("seed\n", encoding="utf-8")
+    _git(repository_root, "add", "-A")
+    _git(repository_root, "commit", "-m", "seed")
+
+
+def _write_and_stage(repository_root: Path, relative_path: str, file_text: str) -> Path:
+    file_path = repository_root / relative_path
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+    file_path.write_text(file_text, encoding="utf-8")
+    _git(repository_root, "add", "--", relative_path)
+    return file_path
+
+
+def _repository_with_root_pytest_config(tmp_path: Path) -> Path:
+    repository_root = tmp_path / "repo"
+    repository_root.mkdir()
+    _init_repository(repository_root)
+    (repository_root / "pytest.ini").write_text("[pytest]\n", encoding="utf-8")
+    return repository_root
+
+
+def test_run_staged_test_files_returns_zero_when_nothing_staged(tmp_path: Path) -> None:
+    repository_root = tmp_path / "repo"
+    repository_root.mkdir()
+    _init_repository(repository_root)
+
+    assert staged_test_running.run_staged_test_files(repository_root) == 0
+
+
+def test_batched_pytest_arguments_splits_over_the_budget() -> None:
+    all_batches = staged_test_running._batched_pytest_arguments(["aaaa", "bbbb", "cccc"], 10)
+    assert all_batches == [["aaaa", "bbbb"], ["cccc"]]
+
+
+def test_batched_pytest_arguments_keeps_oversized_argument_in_its_own_batch() -> None:
+    all_batches = staged_test_running._batched_pytest_arguments(["wide_argument"], 4)
+    assert all_batches == [["wide_argument"]]
+
+
+def test_pytest_target_paths_drops_conftest_and_keeps_real_tests() -> None:
+    all_staged_paths = [
+        Path("pkg_a/conftest.py"),
+        Path("pkg_b/conftest.py"),
+        Path("pkg_a/test_alpha.py"),
+        Path("pkg_b/tests/conftest.py"),
+    ]
+
+    all_targets = staged_test_running._pytest_target_paths(all_staged_paths)
+
+    assert all_targets == [Path("pkg_a/test_alpha.py")]
+
+
+def test_run_staged_test_files_returns_zero_when_only_multiple_confests_staged(
+    tmp_path: Path,
+) -> None:
+    repository_root = _repository_with_root_pytest_config(tmp_path)
+    _write_and_stage(repository_root, "pkg_a/conftest.py", "import pytest\n")
+    _write_and_stage(repository_root, "pkg_b/conftest.py", "import pytest\n")
+    _write_and_stage(
+        repository_root, "pkg_c/tests/conftest.py", "import pytest\n"
+    )
+
+    assert staged_test_running.run_staged_test_files(repository_root) == 0
+
+
+def test_run_staged_test_files_passes_when_confests_stage_with_passing_test(
+    tmp_path: Path,
+) -> None:
+    repository_root = _repository_with_root_pytest_config(tmp_path)
+    _write_and_stage(repository_root, "pkg_a/conftest.py", "import pytest\n")
+    _write_and_stage(repository_root, "pkg_b/conftest.py", "import pytest\n")
+    _write_and_stage(
+        repository_root,
+        "pkg_a/test_alpha.py",
+        "def test_alpha_passes() -> None:\n    assert True\n",
+    )
+
+    assert staged_test_running.run_staged_test_files(repository_root) == 0
+
+
+def test_run_staged_test_files_fails_when_real_test_fails_alongside_confests(
+    tmp_path: Path,
+) -> None:
+    repository_root = _repository_with_root_pytest_config(tmp_path)
+    _write_and_stage(repository_root, "pkg_a/conftest.py", "import pytest\n")
+    _write_and_stage(repository_root, "pkg_b/conftest.py", "import pytest\n")
+    _write_and_stage(
+        repository_root,
+        "pkg_a/test_alpha.py",
+        "def test_alpha_fails() -> None:\n    assert False\n",
+    )
+
+    assert staged_test_running.run_staged_test_files(repository_root) != 0

package/_shared/pr-loop/scripts/code_rules_gate_parts/tests/test_violation_scoping.py

@@ -0,0 +1,75 @@
+"""Behavioral tests for the violation_scoping parts module."""
+
+from code_rules_gate_parts import violation_scoping
+
+
+def test_hunk_header_pattern_matches_a_unified_zero_header() -> None:
+    match_result = violation_scoping.hunk_header_pattern().match("@@ -1,0 +5,3 @@")
+    assert match_result is not None
+    assert match_result.group(1) == "5"
+
+
+def test_violation_line_pattern_extracts_the_line_prefix() -> None:
+    match_result = violation_scoping.violation_line_pattern().match("Line 7: issue")
+    assert match_result is not None
+    assert match_result.group(1) == "7"
+
+
+def test_parse_added_line_numbers_reads_hunk_headers() -> None:
+    diff_text = "@@ -0,0 +3,2 @@\n+alpha\n+beta\n"
+    assert violation_scoping.parse_added_line_numbers(diff_text) == {3, 4}
+
+
+def test_extract_violation_line_number_reads_the_prefix() -> None:
+    assert violation_scoping.extract_violation_line_number("Line 9: issue") == 9
+    assert violation_scoping.extract_violation_line_number("no prefix") is None
+
+
+def test_function_length_span_range_covers_the_declared_span() -> None:
+    message = "Function 'f' (defined at line 4) is 3 lines - too long"
+    assert violation_scoping.function_length_span_range(message) == range(4, 7)
+
+
+def test_isolation_span_range_covers_enclosing_test() -> None:
+    message = "Line 5: Test 'f' (defined at line 4, spanning 3 lines) probes HOME"
+    assert violation_scoping.isolation_span_range(message) == range(4, 7)
+
+
+def test_banned_noun_span_range_is_one_line() -> None:
+    message = "Line 8: Identifier 'result' (binding span at line 8, spanning 1 lines)"
+    assert violation_scoping.banned_noun_span_range(message) == range(8, 9)
+
+
+def test_duplicate_body_span_range_covers_copy() -> None:
+    message = "Function 'f' duplicates a.py::f — (duplicate body span at line 2, spanning 4 lines)"
+    assert violation_scoping.duplicate_body_span_range(message) == range(2, 6)
+
+
+def test_inline_duplicate_body_span_lines_unions_both_spans() -> None:
+    message = (
+        "same body (inline duplicate body spans: helper at line 2 spanning 2 lines, "
+        "enclosing at line 10 spanning 2 lines)"
+    )
+    span_lines = violation_scoping.inline_duplicate_body_span_lines(message)
+    assert span_lines == frozenset({2, 3, 10, 11})
+
+
+def test_enclosing_span_range_dispatches_to_first_extractor() -> None:
+    message = "Function 'f' (defined at line 4) is 3 lines - too long"
+    assert violation_scoping.enclosing_span_range(message) == range(4, 7)
+
+
+def test_split_violations_by_scope_partitions_by_added_line() -> None:
+    blocking, advisory = violation_scoping.split_violations_by_scope(
+        ["Line 5: touched", "Line 9: untouched"], {5}
+    )
+    assert blocking == ["Line 5: touched"]
+    assert advisory == ["Line 9: untouched"]
+
+
+def test_split_violations_by_scope_blocks_everything_when_scope_is_none() -> None:
+    blocking, advisory = violation_scoping.split_violations_by_scope(
+        ["Line 5: a", "Line 9: b"], None
+    )
+    assert blocking == ["Line 5: a", "Line 9: b"]
+    assert advisory == []