claude-dev-env 8.10.0 → 8.11.0

package/hooks/blocking/tdd_enforcer_parts/decisions.py

@@ -1,96 +0,0 @@
-"""Build and emit the gate's allow and deny decisions.
-
-Writes the PreToolUse decision JSON to stdout and, on a deny, records the block
-and attaches the short user-facing notice.
-"""
-
-import json
-import sys
-from pathlib import Path
-
-from tdd_enforcer_parts.config.tdd_enforcer_constants import (
-    ENTRY_HOOK_FILE_NAME,
-    FRESHNESS_WINDOW_SECONDS,
-    NEWLINE_JOIN_SEPARATOR,
-)
-
-from hooks_constants.hook_block_logger import log_hook_block
-from hooks_constants.messages import USER_FACING_TDD_NOTICE
-
-
-def _entry_hook_path() -> Path:
-    """Return the entry hook file that wires the gate's exemption rules together.
-
-    The exemption logic the deny message points at lives in the entry hook
-    beside this parts package, not in this emit-only module::
-
-        tdd_enforcer_parts/decisions.py  ->  parent  ->  blocking/
-        blocking/tdd_enforcer.py         <-  the named exemption home
-
-    So the guidance names the entry hook, letting a reader land on the module
-    that actually decides exemptions.
-    """
-    return Path(__file__).resolve().parent.parent / ENTRY_HOOK_FILE_NAME
-
-
-def build_deny_reason(production_path: Path, all_candidates: list[Path]) -> str:
-    """Return the verbose deny message naming the candidate test files.
-
-    Args:
-        production_path: The production file the write targets.
-        all_candidates: Candidate test paths the gate looked for.
-
-    Returns:
-        The multi-line reason shown when no fresh test satisfies the gate.
-    """
-    candidate_lines = NEWLINE_JOIN_SEPARATOR.join(f"  - {each_path}" for each_path in all_candidates)
-    hook_source_path = _entry_hook_path()
-    return (
-        f"[TDD] Blocking write to production file: {production_path}\n"
-        f"No matching test file exists. Or none of them is fresh, carries real test "
-        f"evidence, and holds content HEAD does not have yet. Or a previously "
-        f"recorded test's content has not changed within the last "
-        f"{FRESHNESS_WINDOW_SECONDS} seconds. Write a new test or change an "
-        f"existing one; touching a file without changing its content does not "
-        f"satisfy this gate.\n"
-        f"Expected one of:\n{candidate_lines}\n"
-        f"Write a failing test first (RED), then the minimum code to pass it (GREEN).\n\n"
-        f"If this file legitimately does not need a test (for example, a module containing only "
-        f"module-level constants with no behavior), that is a hook enhancement, not a bypass. "
-        f"Propose an exemption rule in {hook_source_path} so every similar file benefits "
-        f"automatically. Do not add escape-hatch markers to production files."
-    )
-
-
-def emit_allow() -> None:
-    """Write the allow decision to stdout."""
-    allow_payload = {
-        "hookSpecificOutput": {
-            "hookEventName": "PreToolUse",
-            "permissionDecision": "allow",
-        }
-    }
-    sys.stdout.write(json.dumps(allow_payload))
-
-
-def emit_deny(reason: str) -> None:
-    """Write the deny decision to stdout and record the block.
-
-    Args:
-        reason: The verbose deny reason shown to the agent.
-    """
-    deny_payload = {
-        "hookSpecificOutput": {
-            "hookEventName": "PreToolUse",
-            "permissionDecision": "deny",
-            "permissionDecisionReason": reason,
-        },
-        "suppressOutput": True,
-        "systemMessage": USER_FACING_TDD_NOTICE,
-    }
-    log_hook_block(
-        calling_hook_name="tdd_enforcer.py",
-        hook_event="PreToolUse",
-        block_reason=reason,
-    )
-    sys.stdout.write(json.dumps(deny_payload))

package/hooks/blocking/tdd_enforcer_parts/freshness.py

@@ -1,95 +0,0 @@
-"""Freshness check for the candidate test files the gate resolves.
-
-A candidate satisfies the gate when it was modified inside the freshness window
-and holds a real test function, so a stale test or a same-named file with no
-test evidence does not open the gate.
-"""
-
-import re
-import time
-from pathlib import Path
-
-from tdd_enforcer_parts.config.tdd_enforcer_constants import FRESHNESS_WINDOW_SECONDS
-
-
-def _freshness_seconds() -> int:
-    return FRESHNESS_WINDOW_SECONDS
-
-
-def _test_file_encoding() -> str:
-    return "utf-8"
-
-
-def _test_function_patterns() -> tuple[re.Pattern[str], ...]:
-    return (
-        re.compile(r"\bdef\s+test_"),
-        re.compile(r"\b(?:it|test|describe)\s*\("),
-    )
-
-
-def _safe_mtime(candidate_path: Path) -> float | None:
-    try:
-        return candidate_path.stat().st_mtime
-    except (FileNotFoundError, OSError):
-        return None
-
-
-def _read_candidate_text(candidate_path: Path) -> str | None:
-    try:
-        with candidate_path.open("r", encoding=_test_file_encoding(), errors="ignore") as each_file:
-            return each_file.read()
-    except (FileNotFoundError, OSError):
-        return None
-
-
-def has_test_evidence_in(candidate_text: str) -> bool:
-    """Return whether the given text holds a real test function.
-
-    Takes the text rather than the path, so a caller that has already read the
-    file does not read it a second time.
-
-    Args:
-        candidate_text: The candidate test file's full text.
-
-    Returns:
-        True when the text matches any test-function pattern.
-    """
-    return any(
-        each_pattern.search(candidate_text) for each_pattern in _test_function_patterns()
-    )
-
-
-def _contains_test_evidence(candidate_path: Path) -> bool:
-    test_file_content = _read_candidate_text(candidate_path)
-    if test_file_content is None:
-        return False
-    return has_test_evidence_in(test_file_content)
-
-
-def _candidate_is_fresh_test(
-    candidate_path: Path, current_time: float, freshness_seconds: int
-) -> bool:
-    candidate_mtime = _safe_mtime(candidate_path)
-    if candidate_mtime is None:
-        return False
-    if current_time - candidate_mtime > freshness_seconds:
-        return False
-    return _contains_test_evidence(candidate_path)
-
-
-def has_fresh_test(all_candidates: list[Path], freshness_seconds: int) -> bool:
-    """Return whether any candidate is a recently modified real test file.
-
-    Args:
-        all_candidates: Candidate test paths for the production file.
-        freshness_seconds: Maximum age, in seconds, a test may have.
-
-    Returns:
-        True when at least one candidate was modified within the window and
-        holds a test function.
-    """
-    current_time = time.time()
-    return any(
-        _candidate_is_fresh_test(each_candidate, current_time, freshness_seconds)
-        for each_candidate in all_candidates
-    )

package/hooks/blocking/tdd_enforcer_parts/git_tracking.py

@@ -1,132 +0,0 @@
-"""Ask git about a candidate path: is it a restore, and does it carry a real edit.
-
-::
-
-    remove orders.py (git-tracked) -> Write orders.py  -> restore (allow)
-    Write brand_new.py (untracked, absent)             -> new code (gate)
-
-A full rewrite happens as remove-then-Write, so the file is absent on disk
-between the two steps. Restoring committed code is not new production code, so
-the gate exempts a Write whose target is absent yet tracked in git.
-
-``has_uncommitted_change_from_head`` answers a second, related question the
-content-hash store's first-sight check needs: whether a candidate test file
-already carries content HEAD does not have, so a `touch` on an already-clean,
-committed test cannot pass as a first sighting.
-"""
-
-import subprocess
-from pathlib import Path
-
-from tdd_enforcer_parts.config.tdd_enforcer_constants import (
-    GIT_DIFF_QUIET_FLAG,
-    GIT_DIFF_SUBCOMMAND,
-    GIT_DIFF_TIMEOUT_SECONDS,
-    GIT_EXECUTABLE_NAME,
-    GIT_HEAD_REVISION,
-    GIT_LS_FILES_SUBCOMMAND,
-    GIT_LS_FILES_TIMEOUT_SECONDS,
-    GIT_PATHSPEC_SEPARATOR,
-)
-
-from hooks_constants.subprocess_window import hidden_window_creation_flags
-
-
-def _git_ls_files_command(file_name: str) -> list[str]:
-    return [GIT_EXECUTABLE_NAME, GIT_LS_FILES_SUBCOMMAND, GIT_PATHSPEC_SEPARATOR, file_name]
-
-
-def _git_diff_quiet_against_head_command(file_name: str) -> list[str]:
-    return [
-        GIT_EXECUTABLE_NAME,
-        GIT_DIFF_SUBCOMMAND,
-        GIT_DIFF_QUIET_FLAG,
-        GIT_HEAD_REVISION,
-        GIT_PATHSPEC_SEPARATOR,
-        file_name,
-    ]
-
-
-def _git_tracks_path(path: Path) -> bool:
-    parent_directory = path.parent
-    if not parent_directory.is_dir():
-        return False
-    try:
-        completed = subprocess.run(
-            _git_ls_files_command(path.name),
-            cwd=str(parent_directory),
-            capture_output=True,
-            text=True,
-            check=False,
-            timeout=GIT_LS_FILES_TIMEOUT_SECONDS,
-            creationflags=hidden_window_creation_flags(),
-        )
-    except (OSError, subprocess.SubprocessError):
-        return False
-    return completed.returncode == 0 and bool(completed.stdout.strip())
-
-
-def _working_tree_differs_from_head(path: Path) -> bool:
-    """Compare the working tree to HEAD, not to the index.
-
-    A plain ``git diff`` (no revision argument) compares the working tree to
-    the index, so a file that was just ``git add``-ed reads as unchanged even
-    when it holds content HEAD never had. Naming ``HEAD`` folds the index and
-    the working tree into one comparison against the last commit, catching a
-    staged-but-uncommitted new file and a staged edit alike.
-    """
-    try:
-        completed = subprocess.run(
-            _git_diff_quiet_against_head_command(path.name),
-            cwd=str(path.parent),
-            capture_output=True,
-            text=True,
-            check=False,
-            timeout=GIT_DIFF_TIMEOUT_SECONDS,
-            creationflags=hidden_window_creation_flags(),
-        )
-    except (OSError, subprocess.SubprocessError):
-        return True
-    return completed.returncode != 0
-
-
-def is_absent_but_tracked(path: Path) -> bool:
-    """Return whether a write target is absent on disk yet tracked in git.
-
-    ::
-
-        path missing on disk + git ls-files finds it -> True  (restore)
-        path present, or git does not track it       -> False
-
-    Args:
-        path: The write target.
-
-    Returns:
-        True only when the path does not exist but git tracks it, marking the
-        write a restore of committed code rather than new production code.
-    """
-    if path.exists():
-        return False
-    return _git_tracks_path(path)
-
-
-def has_uncommitted_change_from_head(path: Path) -> bool:
-    """Return whether *path* carries content its git HEAD does not have.
-
-    ::
-
-        untracked file                -> True  (no HEAD entry to match)
-        tracked, working tree != HEAD -> True  (a real edit this session)
-        tracked, working tree == HEAD -> False (clean; a touch cannot pass)
-        git unavailable or errors     -> True  (cannot prove it is clean)
-
-    Args:
-        path: The candidate test file to check.
-
-    Returns:
-        True unless git can positively confirm the file is tracked and its
-        working-tree content matches HEAD exactly.
-    """
-    if not _git_tracks_path(path):
-        return True
-    return _working_tree_differs_from_head(path)

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