claude-dev-env 8.9.0 → 8.11.0

package/hooks/blocking/tdd_enforcer_parts/path_classification.py

@@ -1,119 +0,0 @@
-"""Path and payload classification for the TDD-enforcer gate.
-
-Decides which write targets the gate skips silently (docs, tests, files inside a
-``.claude`` tree) and pulls the written text out of a Write, Edit, or MultiEdit
-payload so the gate can inspect it.
-"""
-
-from tdd_enforcer_parts.config.tdd_enforcer_constants import (
-    ALL_DIRECTORY_SKIP_COMPONENTS,
-    ALL_DOTCLAUDE_PATH_SEGMENTS,
-    ALL_PRODUCTION_EXTENSIONS,
-    ALL_SKIP_EXTENSIONS,
-    ALL_SKIP_NAME_PATTERNS,
-    NEWLINE_JOIN_SEPARATOR,
-)
-
-
-def production_extensions() -> frozenset[str]:
-    """Return the source-file extensions the gate treats as production code."""
-    return ALL_PRODUCTION_EXTENSIONS
-
-
-def skip_extensions() -> frozenset[str]:
-    """Return the config and documentation extensions the gate skips."""
-    return ALL_SKIP_EXTENSIONS
-
-
-def _skip_patterns() -> frozenset[str]:
-    return ALL_SKIP_NAME_PATTERNS
-
-
-def _dotclaude_path_segments() -> frozenset[str]:
-    return ALL_DOTCLAUDE_PATH_SEGMENTS
-
-
-def _directory_skip_components() -> frozenset[str]:
-    return ALL_DIRECTORY_SKIP_COMPONENTS
-
-
-def _is_inside_dotclaude_segment(file_path_string: str) -> bool:
-    """Return whether any path segment is exactly a ``.claude`` directory.
-
-    Args:
-        file_path_string: The write target path, in either separator style.
-
-    Returns:
-        True when a ``.claude`` directory sits on the path, so the gate leaves
-        agent-config edits alone.
-    """
-    normalized_path = file_path_string.replace("\\", "/")
-    dotclaude_segments = _dotclaude_path_segments()
-    for each_segment in normalized_path.split("/"):
-        if each_segment and each_segment in dotclaude_segments:
-            return True
-    return False
-
-
-def _path_has_skip_directory_component(path_with_forward_slashes: str) -> bool:
-    all_components = [each_part for each_part in path_with_forward_slashes.split("/") if each_part]
-    directory_components = all_components[:-1]
-    skip_directory_components = _directory_skip_components()
-    return any(each in skip_directory_components for each in directory_components)
-
-
-def _skip_pattern_matches(pattern: str, name_lower: str, path_with_forward_slashes: str) -> bool:
-    if pattern.endswith("/"):
-        return pattern in path_with_forward_slashes
-    return pattern in name_lower
-
-
-def _name_or_path_matches_skip_pattern(name_lower: str, path_with_forward_slashes: str) -> bool:
-    for each_pattern in _skip_patterns():
-        if _skip_pattern_matches(each_pattern, name_lower, path_with_forward_slashes):
-            return True
-    return False
-
-
-def _matches_any_skip_pattern(name_lower: str, path_with_forward_slashes: str) -> bool:
-    """Return whether a path names a test, fixture, mock, or stub file.
-
-    Args:
-        name_lower: The lower-cased file name.
-        path_with_forward_slashes: The lower-cased path with forward slashes.
-
-    Returns:
-        True when a skip directory component or a skip name pattern matches.
-    """
-    if _path_has_skip_directory_component(path_with_forward_slashes):
-        return True
-    return _name_or_path_matches_skip_pattern(name_lower, path_with_forward_slashes)
-
-
-def _multiedit_new_strings(all_edits: list) -> list[str]:
-    all_new_strings: list[str] = []
-    for each_edit in all_edits:
-        if isinstance(each_edit, dict):
-            all_new_strings.append(each_edit.get("new_string", "") or "")
-    return all_new_strings
-
-
-def _extract_written_content(tool_name: str, tool_input: dict) -> str:
-    """Return the text a Write, Edit, or MultiEdit payload would introduce.
-
-    Args:
-        tool_name: The intercepted tool name.
-        tool_input: The intercepted tool's input payload.
-
-    Returns:
-        The written content for Write, the replacement for Edit, the joined
-        replacements for MultiEdit, or an empty string for any other tool.
-    """
-    if tool_name == "Write":
-        return tool_input.get("content", "") or ""
-    if tool_name == "Edit":
-        return tool_input.get("new_string", "") or ""
-    if tool_name == "MultiEdit":
-        all_edits = tool_input.get("edits", []) or []
-        return NEWLINE_JOIN_SEPARATOR.join(_multiedit_new_strings(all_edits))
-    return ""

package/hooks/blocking/tdd_enforcer_parts/tests/test_candidate_paths.py

@@ -1,31 +0,0 @@
-"""Behavioral tests for the candidate_paths parts module."""
-
-from pathlib import Path
-
-from tdd_enforcer_parts import candidate_paths
-
-
-def test_candidate_paths_offers_flat_stem_candidates_first(tmp_path: Path) -> None:
-    (tmp_path / ".git").mkdir()
-    all_candidates = candidate_paths.candidate_test_paths_for(tmp_path / "orders.py")
-    assert all_candidates[0] == tmp_path / "test_orders.py"
-    assert all_candidates[1] == tmp_path / "orders_test.py"
-
-
-def test_candidate_paths_returns_empty_for_unknown_extension(tmp_path: Path) -> None:
-    assert candidate_paths.candidate_test_paths_for(tmp_path / "data.rs") == []
-
-
-def test_candidate_paths_offers_javascript_test_siblings(tmp_path: Path) -> None:
-    all_candidates = candidate_paths.candidate_test_paths_for(tmp_path / "Button.tsx")
-    assert tmp_path / "Button.test.tsx" in all_candidates
-
-
-def test_ancestor_tests_directories_finds_sibling_tests(tmp_path: Path) -> None:
-    (tmp_path / ".git").mkdir()
-    package = tmp_path / "pkg"
-    package.mkdir()
-    (package / "tests").mkdir()
-    all_pairs = candidate_paths._ancestor_tests_directories(package)
-    all_tests_directories = [each_tests_directory for _, each_tests_directory in all_pairs]
-    assert package / "tests" in all_tests_directories

package/hooks/blocking/tdd_enforcer_parts/tests/test_content_hash_store.py

@@ -1,256 +0,0 @@
-"""Behavioral tests for the content_hash_store parts module.
-
-Covers the recorded-test-failure evidence path: a genuinely failing test
-command outranks a stale mtime, never satisfies a candidate it did not
-name, expires after the freshness window, and applies only while the
-candidate's content still matches what actually failed. Also covers the
-private decision helpers by name, so a rename keeps its own paired test.
-"""
-
-import json
-import os
-import time
-from pathlib import Path
-
-from tdd_enforcer_parts import content_hash_store
-
-
-def _write_fresh_test_file(directory: Path, content: str = "def test_fulfill(): pass\n") -> Path:
-    candidate = directory / "test_orders.py"
-    candidate.write_text(content)
-    return candidate
-
-
-def test_state_file_path_differs_by_repository_root(tmp_path: Path) -> None:
-    first_root_path = content_hash_store._state_file_path("session-a", str(tmp_path / "one"))
-    second_root_path = content_hash_store._state_file_path("session-a", str(tmp_path / "two"))
-    assert first_root_path != second_root_path
-
-
-def test_state_file_path_is_stable_for_the_same_inputs(tmp_path: Path) -> None:
-    first_lookup = content_hash_store._state_file_path("session-a", str(tmp_path))
-    second_lookup = content_hash_store._state_file_path("session-a", str(tmp_path))
-    assert first_lookup == second_lookup
-
-
-def test_first_sight_allows_and_stores_a_fresh_dirty_test(tmp_path: Path) -> None:
-    candidate = _write_fresh_test_file(tmp_path)
-
-    is_allowed = content_hash_store.has_recorded_or_fresh_test(
-        [candidate], "session-1", str(tmp_path), 600
-    )
-
-    assert is_allowed is True
-    state_file = content_hash_store._state_file_path("session-1", str(tmp_path))
-    state = json.loads(state_file.read_text())
-    assert content_hash_store._state_key_for(candidate) in state
-
-
-def test_first_sight_denies_when_test_evidence_is_missing(tmp_path: Path) -> None:
-    candidate = _write_fresh_test_file(tmp_path, content="orders = 'not a test'\n")
-
-    is_allowed = content_hash_store.has_recorded_or_fresh_test(
-        [candidate], "session-2", str(tmp_path), 600
-    )
-
-    assert is_allowed is False
-
-
-def test_first_sight_denies_when_test_file_is_stale(tmp_path: Path) -> None:
-    candidate = _write_fresh_test_file(tmp_path)
-    stale_timestamp = time.time() - 700
-    os.utime(candidate, (stale_timestamp, stale_timestamp))
-
-    is_allowed = content_hash_store.has_recorded_or_fresh_test(
-        [candidate], "session-3", str(tmp_path), 600
-    )
-
-    assert is_allowed is False
-
-
-def test_second_sight_denies_a_touch_that_leaves_content_unchanged(tmp_path: Path) -> None:
-    candidate = _write_fresh_test_file(tmp_path)
-    session_id, repository_root = "session-4", str(tmp_path)
-    assert content_hash_store.has_recorded_or_fresh_test(
-        [candidate], session_id, repository_root, 600
-    )
-    state_file = content_hash_store._state_file_path(session_id, repository_root)
-    state = json.loads(state_file.read_text())
-    candidate_key = content_hash_store._state_key_for(candidate)
-    state[candidate_key][content_hash_store.STORED_CHANGED_AT_KEY] -= 700
-    state_file.write_text(json.dumps(state))
-    candidate.touch()
-
-    is_allowed = content_hash_store.has_recorded_or_fresh_test(
-        [candidate], session_id, repository_root, 600
-    )
-
-    assert is_allowed is False
-
-
-def test_second_sight_allows_when_content_actually_changed_after_the_window(
-    tmp_path: Path,
-) -> None:
-    candidate = _write_fresh_test_file(tmp_path)
-    session_id, repository_root = "session-5", str(tmp_path)
-    assert content_hash_store.has_recorded_or_fresh_test(
-        [candidate], session_id, repository_root, 600
-    )
-    state_file = content_hash_store._state_file_path(session_id, repository_root)
-    state = json.loads(state_file.read_text())
-    candidate_key = content_hash_store._state_key_for(candidate)
-    state[candidate_key][content_hash_store.STORED_CHANGED_AT_KEY] -= 700
-    state_file.write_text(json.dumps(state))
-    candidate.write_text("def test_fulfill(): assert True\n")
-
-    is_allowed = content_hash_store.has_recorded_or_fresh_test(
-        [candidate], session_id, repository_root, 600
-    )
-
-    assert is_allowed is True
-
-
-def test_second_sight_allows_a_repeat_write_within_the_window_untouched(
-    tmp_path: Path,
-) -> None:
-    candidate = _write_fresh_test_file(tmp_path)
-    session_id, repository_root = "session-6", str(tmp_path)
-    assert content_hash_store.has_recorded_or_fresh_test(
-        [candidate], session_id, repository_root, 600
-    )
-
-    is_allowed = content_hash_store.has_recorded_or_fresh_test(
-        [candidate], session_id, repository_root, 600
-    )
-
-    assert is_allowed is True
-
-
-def test_any_candidate_satisfying_the_gate_allows_the_write(tmp_path: Path) -> None:
-    stale_candidate = _write_fresh_test_file(tmp_path)
-    stale_timestamp = time.time() - 700
-    os.utime(stale_candidate, (stale_timestamp, stale_timestamp))
-    fresh_candidate = tmp_path / "orders_test.py"
-    fresh_candidate.write_text("def test_fulfill(): pass\n")
-
-    is_allowed = content_hash_store.has_recorded_or_fresh_test(
-        [stale_candidate, fresh_candidate], "session-7", str(tmp_path), 600
-    )
-
-    assert is_allowed is True
-
-
-def test_denies_when_no_candidate_file_exists(tmp_path: Path) -> None:
-    missing_candidate = tmp_path / "test_missing.py"
-
-    is_allowed = content_hash_store.has_recorded_or_fresh_test(
-        [missing_candidate], "session-8", str(tmp_path), 600
-    )
-
-    assert is_allowed is False
-
-
-def test_recorded_failure_allows_a_stale_candidate(tmp_path: Path) -> None:
-    """RED-evidence: a genuinely recorded failure outranks a stale mtime."""
-    candidate = _write_fresh_test_file(tmp_path)
-    stale_timestamp = time.time() - 700
-    os.utime(candidate, (stale_timestamp, stale_timestamp))
-    session_id, repository_root = "session-failure-1", str(tmp_path)
-    content_hash_store.record_test_command_failure(
-        [candidate], "pytest test_orders.py", 1, session_id, repository_root
-    )
-
-    is_allowed = content_hash_store.has_recorded_or_fresh_test(
-        [candidate], session_id, repository_root, 600
-    )
-
-    assert is_allowed is True
-
-
-def test_recorded_failure_stores_the_command_and_exit_status(tmp_path: Path) -> None:
-    candidate = _write_fresh_test_file(tmp_path)
-    session_id, repository_root = "session-failure-2", str(tmp_path)
-
-    content_hash_store.record_test_command_failure(
-        [candidate], "pytest test_orders.py -q", 1, session_id, repository_root
-    )
-
-    state_file = content_hash_store._state_file_path(session_id, repository_root)
-    state = json.loads(state_file.read_text())
-    entry = state[content_hash_store._state_key_for(candidate)]
-    assert entry[content_hash_store.STORED_FAILURE_COMMAND_KEY] == "pytest test_orders.py -q"
-    assert entry[content_hash_store.STORED_FAILURE_EXIT_STATUS_KEY] == 1
-
-
-def test_recorded_failure_does_not_satisfy_a_different_candidate(tmp_path: Path) -> None:
-    """Anti-bypass: a failure recorded for one test file must not unlock a sibling."""
-    failing_candidate = tmp_path / "test_bar.py"
-    failing_candidate.write_text("def test_bar(): pass\n")
-    unrelated_candidate = tmp_path / "test_foo.py"
-    unrelated_candidate.write_text("def test_foo(): pass\n")
-    stale_timestamp = time.time() - 700
-    os.utime(unrelated_candidate, (stale_timestamp, stale_timestamp))
-    session_id, repository_root = "session-failure-3", str(tmp_path)
-    content_hash_store.record_test_command_failure(
-        [failing_candidate], "pytest test_bar.py", 1, session_id, repository_root
-    )
-
-    is_allowed = content_hash_store.has_recorded_or_fresh_test(
-        [unrelated_candidate], session_id, repository_root, 600
-    )
-
-    assert is_allowed is False
-
-
-def test_recorded_failure_expires_after_the_freshness_window(tmp_path: Path) -> None:
-    candidate = _write_fresh_test_file(tmp_path)
-    stale_timestamp = time.time() - 700
-    os.utime(candidate, (stale_timestamp, stale_timestamp))
-    session_id, repository_root = "session-failure-4", str(tmp_path)
-    state_file = content_hash_store._state_file_path(session_id, repository_root)
-    candidate_key = content_hash_store._state_key_for(candidate)
-    stale_failed_at = time.time() - 700
-    state_file.write_text(
-        json.dumps(
-            {
-                candidate_key: {
-                    content_hash_store.STORED_FAILURE_HASH_KEY: content_hash_store._content_hash(
-                        candidate.read_text()
-                    ),
-                    content_hash_store.STORED_FAILED_AT_KEY: stale_failed_at,
-                }
-            }
-        )
-    )
-
-    is_allowed = content_hash_store.has_recorded_or_fresh_test(
-        [candidate], session_id, repository_root, 600
-    )
-
-    assert is_allowed is False
-
-
-def test_recorded_failure_does_not_apply_once_content_no_longer_matches(
-    tmp_path: Path,
-) -> None:
-    """Anti-bypass: editing the test after a recorded RED clears that RED as evidence.
-
-    A bare failure-only entry (no prior content-hash tracking) must not fall
-    through to the unconditional hash-differs allow either -- it still needs a
-    real qualifying first sight (fresh mtime plus a real git-visible edit).
-    """
-    candidate = tmp_path / "test_orders.py"
-    candidate.write_text("def test_fulfill(): pass\n")
-    session_id, repository_root = "session-failure-5", str(tmp_path)
-    content_hash_store.record_test_command_failure(
-        [candidate], "pytest test_orders.py", 1, session_id, repository_root
-    )
-    candidate.write_text("def test_fulfill(): assert True\n")
-    stale_timestamp = time.time() - 700
-    os.utime(candidate, (stale_timestamp, stale_timestamp))
-
-    is_allowed = content_hash_store.has_recorded_or_fresh_test(
-        [candidate], session_id, repository_root, 600
-    )
-
-    assert is_allowed is False

package/hooks/blocking/tdd_enforcer_parts/tests/test_decisions.py

@@ -1,46 +0,0 @@
-"""Behavioral tests for the decisions parts module."""
-
-import json
-from pathlib import Path
-
-import pytest
-from tdd_enforcer_parts import decisions
-
-
-def test_build_deny_reason_names_candidates_and_production_path() -> None:
-    reason = decisions.build_deny_reason(Path("pkg/orders.py"), [Path("pkg/test_orders.py")])
-    assert "orders.py" in reason
-    assert "test_orders.py" in reason
-    assert "propose" in reason.lower() or "enhancement" in reason.lower()
-
-
-def test_build_deny_reason_points_exemption_guidance_at_entry_hook() -> None:
-    reason = decisions.build_deny_reason(Path("pkg/orders.py"), [])
-    assert "tdd_enforcer.py" in reason
-    assert "decisions.py" not in reason
-
-
-def test_build_deny_reason_names_content_not_only_modification_time() -> None:
-    reason = decisions.build_deny_reason(Path("pkg/orders.py"), [Path("pkg/test_orders.py")])
-    assert "content" in reason.lower()
-
-
-def test_build_deny_reason_covers_first_sight_and_stale_hash_and_names_the_fix() -> None:
-    reason = decisions.build_deny_reason(Path("pkg/orders.py"), [Path("pkg/test_orders.py")]).lower()
-    assert "fresh" in reason
-    assert "change" in reason
-    assert "touch" in reason
-
-
-def test_emit_allow_writes_allow_decision(capsys: pytest.CaptureFixture[str]) -> None:
-    decisions.emit_allow()
-    parsed = json.loads(capsys.readouterr().out)
-    assert parsed["hookSpecificOutput"]["permissionDecision"] == "allow"
-
-
-def test_emit_deny_writes_deny_and_system_message(capsys: pytest.CaptureFixture[str]) -> None:
-    decisions.emit_deny("blocked because no fresh test")
-    parsed = json.loads(capsys.readouterr().out)
-    assert parsed["hookSpecificOutput"]["permissionDecision"] == "deny"
-    assert parsed["suppressOutput"] is True
-    assert isinstance(parsed["systemMessage"], str)

package/hooks/blocking/tdd_enforcer_parts/tests/test_freshness.py

@@ -1,28 +0,0 @@
-"""Behavioral tests for the freshness parts module."""
-
-import os
-import time
-from pathlib import Path
-
-from tdd_enforcer_parts import freshness
-
-
-def test_has_fresh_test_true_for_recent_test_file(tmp_path: Path) -> None:
-    test_file = tmp_path / "test_orders.py"
-    test_file.write_text("def test_x(): pass\n")
-    assert freshness.has_fresh_test([test_file], freshness._freshness_seconds()) is True
-
-
-def test_has_fresh_test_false_for_stale_test_file(tmp_path: Path) -> None:
-    test_file = tmp_path / "test_orders.py"
-    test_file.write_text("def test_x(): pass\n")
-    window = freshness._freshness_seconds()
-    stale_timestamp = time.time() - window - 60
-    os.utime(test_file, (stale_timestamp, stale_timestamp))
-    assert freshness.has_fresh_test([test_file], window) is False
-
-
-def test_has_fresh_test_false_when_no_test_evidence(tmp_path: Path) -> None:
-    test_file = tmp_path / "test_orders.py"
-    test_file.write_text("x = 1\n")
-    assert freshness.has_fresh_test([test_file], freshness._freshness_seconds()) is False

package/hooks/blocking/tdd_enforcer_parts/tests/test_git_tracking.py

@@ -1,111 +0,0 @@
-"""Behavioral tests for the git_tracking parts module."""
-
-import os
-import subprocess
-from pathlib import Path
-
-from tdd_enforcer_parts import git_tracking
-
-
-def _git(repository_root: Path, *arguments: str) -> None:
-    subprocess.run(
-        ["git", *arguments],
-        cwd=str(repository_root),
-        check=True,
-        capture_output=True,
-        env={**os.environ, "GIT_CONFIG_GLOBAL": os.devnull, "GIT_CONFIG_SYSTEM": os.devnull},
-    )
-
-
-def _init_repository(repository_root: Path) -> None:
-    _git(repository_root, "init", "-q")
-    _git(repository_root, "config", "user.email", "test@example.com")
-    _git(repository_root, "config", "user.name", "Test")
-    _git(repository_root, "config", "commit.gpgsign", "false")
-
-
-def test_absent_but_tracked_true_after_committed_file_removed(tmp_path: Path) -> None:
-    _init_repository(tmp_path)
-    tracked = tmp_path / "service.py"
-    tracked.write_text("def serve(): return 1\n")
-    _git(tmp_path, "add", "-A")
-    _git(tmp_path, "commit", "-q", "-m", "init")
-    tracked.unlink()
-    assert git_tracking.is_absent_but_tracked(tracked) is True
-
-
-def test_absent_but_tracked_false_for_untracked_absent_file(tmp_path: Path) -> None:
-    _init_repository(tmp_path)
-    assert git_tracking.is_absent_but_tracked(tmp_path / "ghost.py") is False
-
-
-def test_absent_but_tracked_false_when_file_present(tmp_path: Path) -> None:
-    _init_repository(tmp_path)
-    present = tmp_path / "present.py"
-    present.write_text("def here(): return 1\n")
-    _git(tmp_path, "add", "-A")
-    _git(tmp_path, "commit", "-q", "-m", "init")
-    assert git_tracking.is_absent_but_tracked(present) is False
-
-
-def test_has_uncommitted_change_from_head_true_for_untracked_file(tmp_path: Path) -> None:
-    _init_repository(tmp_path)
-    untracked = tmp_path / "test_orders.py"
-    untracked.write_text("def test_fulfill(): pass\n")
-    assert git_tracking.has_uncommitted_change_from_head(untracked) is True
-
-
-def test_has_uncommitted_change_from_head_true_for_tracked_modified_file(tmp_path: Path) -> None:
-    _init_repository(tmp_path)
-    tracked = tmp_path / "test_orders.py"
-    tracked.write_text("def test_fulfill(): pass\n")
-    _git(tmp_path, "add", "-A")
-    _git(tmp_path, "commit", "-q", "-m", "init")
-    tracked.write_text("def test_fulfill(): assert True\n")
-    assert git_tracking.has_uncommitted_change_from_head(tracked) is True
-
-
-def test_has_uncommitted_change_from_head_false_for_tracked_clean_file(tmp_path: Path) -> None:
-    _init_repository(tmp_path)
-    tracked = tmp_path / "test_orders.py"
-    tracked.write_text("def test_fulfill(): pass\n")
-    _git(tmp_path, "add", "-A")
-    _git(tmp_path, "commit", "-q", "-m", "init")
-    tracked.touch()
-    assert git_tracking.has_uncommitted_change_from_head(tracked) is False
-
-
-def test_has_uncommitted_change_from_head_true_outside_a_git_repository(tmp_path: Path) -> None:
-    stray = tmp_path / "test_orders.py"
-    stray.write_text("def test_fulfill(): pass\n")
-    assert git_tracking.has_uncommitted_change_from_head(stray) is True
-
-
-def test_has_uncommitted_change_from_head_true_for_staged_new_file_never_committed(
-    tmp_path: Path,
-) -> None:
-    """A brand-new file only ``git add``-ed carries content HEAD never had.
-
-    Regression guard: comparing the working tree to the index (rather than to
-    HEAD) reads a freshly staged file as unchanged, since staging makes the
-    index match the working tree exactly. That misses every staged-but-never-
-    committed file, which is exactly how a RED-step test file is staged.
-    """
-    _init_repository(tmp_path)
-    _git(tmp_path, "commit", "--allow-empty", "-q", "-m", "baseline")
-    staged_new_test = tmp_path / "test_orders.py"
-    staged_new_test.write_text("def test_fulfill(): pass\n")
-    _git(tmp_path, "add", "-A")
-    assert git_tracking.has_uncommitted_change_from_head(staged_new_test) is True
-
-
-def test_has_uncommitted_change_from_head_true_for_staged_modification(tmp_path: Path) -> None:
-    """A tracked test's staged edit still differs from HEAD, not only the index."""
-    _init_repository(tmp_path)
-    tracked = tmp_path / "test_orders.py"
-    tracked.write_text("def test_fulfill(): pass\n")
-    _git(tmp_path, "add", "-A")
-    _git(tmp_path, "commit", "-q", "-m", "init")
-    tracked.write_text("def test_fulfill(): assert True\n")
-    _git(tmp_path, "add", "-A")
-    assert git_tracking.has_uncommitted_change_from_head(tracked) is True

package/hooks/blocking/tdd_enforcer_parts/tests/test_path_classification.py

@@ -1,36 +0,0 @@
-"""Behavioral tests for the path_classification parts module."""
-
-from tdd_enforcer_parts import path_classification
-
-
-def test_production_extensions_includes_python_and_typescript() -> None:
-    extensions = path_classification.production_extensions()
-    assert ".py" in extensions
-    assert ".tsx" in extensions
-
-
-def test_skip_extensions_includes_markdown_and_json() -> None:
-    extensions = path_classification.skip_extensions()
-    assert ".md" in extensions
-    assert ".json" in extensions
-
-
-def test_is_inside_dotclaude_segment_matches_exact_segment_only() -> None:
-    assert path_classification._is_inside_dotclaude_segment("/home/user/.claude/agent.py") is True
-    assert path_classification._is_inside_dotclaude_segment("/src/my.claude.helpers.py") is False
-
-
-def test_matches_any_skip_pattern_flags_test_file_names() -> None:
-    assert (
-        path_classification._matches_any_skip_pattern("test_orders.py", "pkg/test_orders.py")
-        is True
-    )
-    assert path_classification._matches_any_skip_pattern("orders.py", "pkg/orders.py") is False
-
-
-def test_extract_written_content_reads_write_and_multiedit() -> None:
-    assert path_classification._extract_written_content("Write", {"content": "x"}) == "x"
-    joined = path_classification._extract_written_content(
-        "MultiEdit", {"edits": [{"new_string": "a"}, {"new_string": "b"}]}
-    )
-    assert joined == "a\nb"