claude-dev-env 2.3.0 → 2.4.0

package/hooks/validators/pyproject_config_discovery.py

@@ -0,0 +1,101 @@
+"""Resolve a validator's config file by walking up from an original path.
+
+A staged temp copy has no config in its own ancestors, so ruff and mypy would
+discover nothing there. This walk starts from the ORIGINAL target path and
+returns the first pyproject.toml whose ``[tool.<name>]`` table exists.
+
+::
+
+    tool_table_name="ruff", start .../hooks/validators/module.py
+    -> climbs to .../hooks/pyproject.toml, which declares [tool.ruff] -> that path
+    tool_table_name="ruff", start .../advisor/scripts/module.py
+    -> that pyproject declares [tool.mypy] only, no [tool.ruff] -> None
+"""
+
+import sys
+import tomllib
+from pathlib import Path
+
+_hooks_directory = str(Path(__file__).resolve().parent.parent)
+
+try:
+    from hooks_constants.mypy_integration_constants import PYPROJECT_FILENAME
+    from hooks_constants.pyproject_config_discovery_constants import TOOL_TABLE_KEY
+except ModuleNotFoundError:
+    if _hooks_directory not in sys.path:
+        sys.path.insert(0, _hooks_directory)
+    from hooks_constants.mypy_integration_constants import PYPROJECT_FILENAME
+    from hooks_constants.pyproject_config_discovery_constants import TOOL_TABLE_KEY
+
+
+def ancestor_directories(starting_file: Path) -> list[Path]:
+    """Return *starting_file*'s directory and every parent, nearest first.
+
+    ::
+
+        repo/pkg/mod.py -> [repo/pkg, repo, ... , filesystem root]
+        repo/pkg/       -> [repo/pkg, repo, ... , filesystem root]
+
+    A file resolves to its containing directory; a directory resolves to itself,
+    so both callers start the walk from the same first candidate.
+
+    Args:
+        starting_file: The file (or directory) the walk begins from.
+
+    Returns:
+        The resolved starting directory followed by each of its parents.
+    """
+    resolved_starting_file = starting_file.resolve()
+    walk_origin = (
+        resolved_starting_file.parent
+        if resolved_starting_file.is_file()
+        else resolved_starting_file
+    )
+    return [walk_origin, *walk_origin.parents]
+
+
+def _pyproject_configures_tool(pyproject_path: Path, tool_table_name: str) -> bool:
+    """Return whether *pyproject_path* declares a ``[tool.<tool_table_name>]`` table.
+
+    A malformed or unreadable file counts as no match, so a broken pyproject
+    never shadows a valid config further up the tree.
+
+    Args:
+        pyproject_path: The candidate pyproject.toml to parse.
+        tool_table_name: The tool's table name below ``[tool]`` (for example ``ruff``).
+
+    Returns:
+        True when the parsed file holds ``[tool.<tool_table_name>]``, else False.
+    """
+    try:
+        with pyproject_path.open("rb") as readable_handle:
+            parsed_toml = tomllib.load(readable_handle)
+    except (OSError, tomllib.TOMLDecodeError):
+        return False
+    tool_table = parsed_toml.get(TOOL_TABLE_KEY, {})
+    return isinstance(tool_table, dict) and tool_table_name in tool_table
+
+
+def find_pyproject_configuring_tool(starting_file: Path, tool_table_name: str) -> Path | None:
+    """Walk up from *starting_file* to the first pyproject.toml configuring a tool.
+
+    The walk skips a pyproject.toml that does not declare the tool's table, so an
+    unrelated package config does not shadow a config that actually configures
+    the tool further up the tree.
+
+    Args:
+        starting_file: The file (or directory) the walk begins from — the
+            original target path, not the staged temp copy.
+        tool_table_name: The tool's table name below ``[tool]`` (for example ``ruff``).
+
+    Returns:
+        The first ``pyproject.toml`` Path that declares ``[tool.<tool_table_name>]``,
+        or ``None`` when no such file exists up to the filesystem root.
+    """
+    for each_candidate_directory in ancestor_directories(starting_file):
+        candidate_pyproject = each_candidate_directory / PYPROJECT_FILENAME
+        if candidate_pyproject.is_file() and _pyproject_configures_tool(
+            candidate_pyproject, tool_table_name
+        ):
+            return candidate_pyproject
+    return None

package/hooks/validators/ruff_integration.py

@@ -1,9 +1,29 @@
 """Ruff integration for fast Python linting."""
 
 import subprocess
+import sys
 from dataclasses import dataclass
 from pathlib import Path
 
+_validators_directory = str(Path(__file__).resolve().parent)
+_hooks_directory = str(Path(__file__).resolve().parent.parent)
+
+try:
+    from pyproject_config_discovery import find_pyproject_configuring_tool
+except ModuleNotFoundError:
+    if _validators_directory not in sys.path:
+        sys.path.insert(0, _validators_directory)
+    from pyproject_config_discovery import find_pyproject_configuring_tool
+
+try:
+    from hooks_constants.mypy_integration_constants import PYTHON_SOURCE_SUFFIX
+    from hooks_constants.pyproject_config_discovery_constants import RUFF_TOOL_TABLE_NAME
+except ModuleNotFoundError:
+    if _hooks_directory not in sys.path:
+        sys.path.insert(0, _hooks_directory)
+    from hooks_constants.mypy_integration_constants import PYTHON_SOURCE_SUFFIX
+    from hooks_constants.pyproject_config_discovery_constants import RUFF_TOOL_TABLE_NAME
+
 
 @dataclass
 class RuffResult:
@@ -26,26 +46,165 @@ def check_ruff_available() -> bool:
         return False
 
 
-def run_ruff_check(files: list[Path]) -> RuffResult:
-    """Run ruff check on files."""
-    if not files:
-        return RuffResult(passed=True, output="No files to check", fixed_count=0)
+def find_pyproject_with_ruff_config(starting_file: Path) -> Path | None:
+    """Walk up from a starting file to a pyproject.toml that configures ruff.
 
-    if not check_ruff_available():
-        return RuffResult(passed=True, output="Ruff not installed - skipping", fixed_count=0)
+    The walk skips a pyproject.toml with no [tool.ruff] table, so a mypy-only
+    config is not handed to ``ruff --config``, which errors on the missing table.
+
+    Args:
+        starting_file: The file (or directory) the walk begins from.
+
+    Returns:
+        The first ``pyproject.toml`` Path declaring a ``[tool.ruff]`` table, or
+        ``None`` when none exists up to the filesystem root.
+    """
+    return find_pyproject_configuring_tool(starting_file, RUFF_TOOL_TABLE_NAME)
+
+
+def _ruff_config_argument(config_source_path: Path | None) -> list[str]:
+    """Return the ``--config`` argument resolved from the original path, or empty.
+
+    ::
+
+        config_source_path resolves .../hooks/pyproject.toml
+            -> ["--config", ".../hooks/pyproject.toml"]
+        config_source_path given, no [tool.ruff] up-tree -> [] (native discovery)
+        config_source_path None -> [] (native discovery)
+
+    Args:
+        config_source_path: The original target path the staged copy stands in
+            for, or ``None`` for a native run.
+
+    Returns:
+        The ``--config`` argument vector, empty when no ruff config resolves.
+    """
+    if config_source_path is None:
+        return []
+    resolved_pyproject = find_pyproject_with_ruff_config(config_source_path)
+    if resolved_pyproject is None:
+        return []
+    return ["--config", str(resolved_pyproject)]
 
-    py_files = [str(f) for f in files if f.suffix == ".py"]
-    if not py_files:
-        return RuffResult(passed=True, output="No Python files", fixed_count=0)
 
+def _config_relative_stdin_filename(target_path: Path, config_directory: Path) -> str:
+    """Return *target_path* expressed relative to the ruff config directory.
+
+    ::
+
+        target .../hooks/validators/run_all_validators.py, config dir .../hooks
+            -> "validators/run_all_validators.py"  (path-scoped ignore matches)
+        target off-tree from the config dir -> the bare basename
+
+    Ruff matches ``[tool.ruff.lint.per-file-ignores]`` keys against the path a
+    file presents relative to ruff's working directory, so a path-scoped key
+    matches only when the staged copy is graded under that same relative name.
+
+    Args:
+        target_path: The real target path the staged copy stands in for.
+        config_directory: The directory holding the resolved ruff pyproject.
+
+    Returns:
+        The config-relative POSIX path when the target sits under the config
+        directory, else the target's basename.
+    """
+    resolved_target = target_path.resolve()
+    try:
+        return resolved_target.relative_to(config_directory).as_posix()
+    except ValueError:
+        return resolved_target.name
+
+
+def _read_staged_content(staged_file: Path) -> str | None:
+    """Return the staged copy's text content, or None when it cannot be read."""
+    try:
+        return staged_file.read_text(encoding="utf-8")
+    except OSError:
+        return None
+
+
+def _single_staged_python_file(all_files: list[Path]) -> Path | None:
+    """Return the sole staged Python file, or None unless there is exactly one."""
+    all_python_files = [
+        each_file for each_file in all_files if each_file.suffix == PYTHON_SOURCE_SUFFIX
+    ]
+    if len(all_python_files) != 1:
+        return None
+    return all_python_files[0]
+
+
+def _staged_ruff_command(resolved_pyproject: Path, stdin_filename: str) -> list[str]:
+    """Return the ruff argv that grades stdin under a config-relative name."""
     concise_output_arguments = ["--output-format", "concise"]
+    return [
+        "ruff",
+        "check",
+        "--config",
+        str(resolved_pyproject),
+        *concise_output_arguments,
+        "--stdin-filename",
+        stdin_filename,
+        "-",
+    ]
+
+
+def _staged_ruff_result(
+    resolved_pyproject: Path, stdin_filename: str, staged_content: str
+) -> RuffResult:
+    """Pipe *staged_content* to ruff from the config directory and wrap the result."""
     result = subprocess.run(
-        ["ruff", "check", *concise_output_arguments] + py_files,
+        _staged_ruff_command(resolved_pyproject, stdin_filename),
         check=False,
         capture_output=True,
         text=True,
+        input=staged_content,
+        cwd=str(resolved_pyproject.parent),
     )
+    return RuffResult(
+        passed=result.returncode == 0,
+        output=result.stdout or result.stderr or "No issues found",
+        fixed_count=0,
+    )
+
+
+def _run_staged_ruff_check(
+    all_files: list[Path], config_source_path: Path
+) -> RuffResult | None:
+    """Grade one staged file under the config resolved from its original path.
+
+    The staged content is piped to ruff under ``--stdin-filename`` set to the
+    original target's config-relative name, so ruff applies path-scoped
+    per-file-ignores that never match the temporary copy's own location.
+    Returns None when the staged shape does not apply: no resolvable ruff
+    config, not exactly one Python file, or an unreadable staged copy.
+    """
+    resolved_pyproject = find_pyproject_with_ruff_config(config_source_path)
+    if resolved_pyproject is None:
+        return None
+    staged_file = _single_staged_python_file(all_files)
+    if staged_file is None:
+        return None
+    staged_content = _read_staged_content(staged_file)
+    if staged_content is None:
+        return None
+    stdin_filename = _config_relative_stdin_filename(
+        config_source_path, resolved_pyproject.parent
+    )
+    return _staged_ruff_result(resolved_pyproject, stdin_filename, staged_content)
+
 
+def _run_native_ruff_check(
+    all_python_files: list[str], config_source_path: Path | None
+) -> RuffResult:
+    """Run ruff over *all_python_files* directly, resolving ``--config`` from the path."""
+    config_argument = _ruff_config_argument(config_source_path)
+    concise_output_arguments = ["--output-format", "concise"]
+    result = subprocess.run(
+        ["ruff", "check", *config_argument, *concise_output_arguments] + all_python_files,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
     return RuffResult(
         passed=result.returncode == 0,
         output=result.stdout or result.stderr or "No issues found",
@@ -53,32 +212,61 @@ def run_ruff_check(files: list[Path]) -> RuffResult:
     )
 
 
+def run_ruff_check(
+    all_files: list[Path], config_source_path: Path | None = None
+) -> RuffResult:
+    """Run ruff check on *all_files*, resolving config from *config_source_path*.
+
+    A given ``config_source_path`` grades the single staged copy under the project
+    config resolved from the original target, applying its path-scoped
+    per-file-ignores. Without it, the files are checked natively."""
+    if not all_files:
+        return RuffResult(passed=True, output="No files to check", fixed_count=0)
+
+    if not check_ruff_available():
+        return RuffResult(passed=True, output="Ruff not installed - skipping", fixed_count=0)
+
+    all_python_files = [
+        str(each_file) for each_file in all_files if each_file.suffix == PYTHON_SOURCE_SUFFIX
+    ]
+    if not all_python_files:
+        return RuffResult(passed=True, output="No Python files", fixed_count=0)
+    if config_source_path is not None:
+        staged_result = _run_staged_ruff_check(all_files, config_source_path)
+        if staged_result is not None:
+            return staged_result
+    return _run_native_ruff_check(all_python_files, config_source_path)
+
+
+def _parse_fixed_count(fix_output: str) -> int:
+    """Return the count ruff reports on its ``Fixed N`` line, or 0 when absent."""
+    for each_line in fix_output.split("\n"):
+        if "Fixed" not in each_line:
+            continue
+        try:
+            return int(each_line.split()[1])
+        except (IndexError, ValueError):
+            return 0
+    return 0
+
+
 def run_ruff_fix(files: list[Path]) -> RuffResult:
     """Run ruff with --fix to auto-fix violations."""
     if not check_ruff_available():
         return RuffResult(passed=True, output="Ruff not installed", fixed_count=0)
-
-    py_files = [str(f) for f in files if f.suffix == ".py"]
+    py_files = [
+        str(each_file) for each_file in files if each_file.suffix == PYTHON_SOURCE_SUFFIX
+    ]
     if not py_files:
         return RuffResult(passed=True, output="No Python files", fixed_count=0)
-
     result = subprocess.run(
         ["ruff", "check", "--fix"] + py_files,
         check=False,
         capture_output=True,
         text=True,
     )
-
-    fixed_count = 0
-    for line in result.stdout.split("\n"):
-        if "Fixed" in line:
-            try:
-                fixed_count = int(line.split()[1])
-            except (IndexError, ValueError):
-                pass
-
     return RuffResult(
         passed=result.returncode == 0,
         output=result.stdout or "No fixes applied",
-        fixed_count=fixed_count,
+        fixed_count=_parse_fixed_count(result.stdout),
     )

package/hooks/validators/run_all_validators.py

@@ -413,7 +413,9 @@ def run_comment_checks(files: List[Path]) -> ValidatorResult:
     )
 
 
-def run_ruff_checks(files: List[Path]) -> ValidatorResult:
+def run_ruff_checks(
+    files: List[Path], config_source_path: Optional[Path] = None
+) -> ValidatorResult:
     """Run ruff for fast Python linting."""
     if not check_ruff_available():
         return ValidatorResult(
@@ -423,7 +425,7 @@ def run_ruff_checks(files: List[Path]) -> ValidatorResult:
             output="Ruff not installed - skipping",
         )
 
-    result = run_ruff_check(files)
+    result = run_ruff_check(files, config_source_path)
 
     return ValidatorResult(
         name="Ruff",
@@ -433,7 +435,9 @@ def run_ruff_checks(files: List[Path]) -> ValidatorResult:
     )
 
 
-def run_mypy_checks(files: List[Path]) -> ValidatorResult:
+def run_mypy_checks(
+    files: List[Path], config_source_path: Optional[Path] = None
+) -> ValidatorResult:
     """Run mypy for static type checking."""
     if not check_mypy_available():
         return ValidatorResult(
@@ -443,7 +447,7 @@ def run_mypy_checks(files: List[Path]) -> ValidatorResult:
             output="Mypy not installed - skipping",
         )
 
-    result = run_mypy_check(files)
+    result = run_mypy_check(files, config_source_path)
 
     return ValidatorResult(
         name="Mypy",
@@ -727,15 +731,16 @@ def reconstruct_proposed_content(
     return apply_edits(existing_content, edits_for_tool(tool_name, dict(tool_input)))
 
 
-def run_file_scoped_validators(all_files: List[Path]) -> List[ValidatorResult]:
-    """Run every validator scoped to individual files against *all_files*.
+def run_file_scoped_validators(
+    all_files: List[Path], config_source_path: Optional[Path] = None
+) -> List[ValidatorResult]:
+    """Run every file-scoped validator against *all_files*.
 
-    Excludes the branch-scoped File Structure and Git validators, which grade
-    the whole project rather than a single proposed file.
+    Excludes the branch-scoped File Structure and Git validators.
 
     Args:
-        all_files: The files under validation — a single reconstructed file in
-            gate mode.
+        all_files: The files under validation — one reconstructed file in gate mode.
+        config_source_path: Original path ruff and mypy resolve their config from.
 
     Returns:
         One ValidatorResult per file-scoped validator, in run order.
@@ -744,8 +749,8 @@ def run_file_scoped_validators(all_files: List[Path]) -> List[ValidatorResult]:
         run_python_style_checks(all_files),
         run_test_safety_checks(all_files),
         run_react_checks(all_files),
-        run_ruff_checks(all_files),
-        run_mypy_checks(all_files),
+        run_ruff_checks(all_files, config_source_path),
+        run_mypy_checks(all_files, config_source_path),
         run_abbreviation_checks(all_files),
         run_pr_reference_checks(all_files),
         run_magic_value_checks(all_files),
@@ -765,7 +770,9 @@ def validate_proposed_file(
 
     Writes the content to a temporary file that carries the target's basename so
     suffix-based and test-name-based validator filtering matches the real path,
-    then runs the file-scoped validators against it.
+    then runs the file-scoped validators against it. Ruff and mypy resolve their
+    config by walking up from *file_path*, so the staged copy is graded under the
+    project config the real path sits in rather than the temp directory's.
 
     Args:
         file_path: The destination path the write or edit targets.
@@ -778,7 +785,7 @@ def validate_proposed_file(
     with tempfile.TemporaryDirectory() as temporary_directory:
         temporary_file = Path(temporary_directory) / base_name
         temporary_file.write_text(proposed_content, encoding="utf-8")
-        return run_file_scoped_validators([temporary_file])
+        return run_file_scoped_validators([temporary_file], Path(file_path))
 
 
 def _validator_summaries(results: List[ValidatorResult]) -> str:

package/hooks/validators/test_mypy_integration.py

@@ -165,6 +165,37 @@ def test_run_mypy_check_accepts_relative_path_under_nested_root(
     assert mypy_result.passed, mypy_result.output
 
 
+def test_run_mypy_check_applies_config_resolved_from_config_source_path(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """A staged file is checked under the config resolved from the original path.
+
+    A strict ``[tool.mypy]`` config flags an untyped def only when
+    ``config_source_path`` resolves it; native discovery from the detached
+    file finds no config and passes.
+    """
+    strict_repo = tmp_path / "strict_repo"
+    strict_repo.mkdir()
+    (strict_repo / "pyproject.toml").write_text(
+        "[tool.mypy]\ndisallow_untyped_defs = true\n", encoding="utf-8"
+    )
+    detached_file = tmp_path / "detached" / "untyped.py"
+    detached_file.parent.mkdir(parents=True)
+    detached_file.write_text(
+        "def annotate_nothing(value):\n    return value\n", encoding="utf-8"
+    )
+
+    monkeypatch.chdir(tmp_path)
+
+    without_source = run_mypy_check([detached_file])
+    with_source = run_mypy_check(
+        [detached_file], config_source_path=strict_repo / "pyproject.toml"
+    )
+
+    assert without_source.passed, without_source.output
+    assert not with_source.passed
+
+
 def test_mypy_result_dataclass() -> None:
     """Test MypyResult dataclass creation."""
     result = MypyResult(passed=True, output="test", error_count=0)
@@ -183,6 +214,7 @@ def test_run_mypy_check_returns_passed_for_empty_files() -> None:
     """Test that run_mypy_check passes with no files."""
     result = run_mypy_check([])
     assert result.passed is True
+    assert result.error_count == 0
     assert "No files" in result.output
 
 

package/hooks/validators/test_pyproject_config_discovery.py

@@ -0,0 +1,94 @@
+"""Tests for the shared pyproject config-discovery walk-up primitive.
+
+The primitive walks up from a starting path and returns the first pyproject.toml
+whose ``[tool.<name>]`` table exists, so each tool matches only a config that
+actually configures it — a mypy-only pyproject is no ruff config.
+"""
+
+from pathlib import Path
+
+from hooks_constants.pyproject_config_discovery_constants import (
+    MYPY_TOOL_TABLE_NAME,
+    RUFF_TOOL_TABLE_NAME,
+)
+
+from .pyproject_config_discovery import (
+    ancestor_directories,
+    find_pyproject_configuring_tool,
+)
+
+
+def test_ancestor_directories_lists_directory_then_parents_nearest_first(
+    tmp_path: Path,
+) -> None:
+    nested_directory = tmp_path / "outer" / "inner"
+    nested_directory.mkdir(parents=True)
+    nested_file = nested_directory / "module.py"
+    nested_file.write_text("sample_number: int = 1\n", encoding="utf-8")
+
+    walked = ancestor_directories(nested_file)
+
+    assert walked[0] == nested_directory.resolve()
+    assert walked[1] == (tmp_path / "outer").resolve()
+
+
+def test_find_pyproject_configuring_tool_returns_table_owning_pyproject(
+    tmp_path: Path,
+) -> None:
+    project_root = tmp_path / "project"
+    nested_directory = project_root / "src" / "deep"
+    nested_directory.mkdir(parents=True)
+    owning_pyproject = project_root / "pyproject.toml"
+    owning_pyproject.write_text("[tool.ruff.lint]\nselect = ['B']\n", encoding="utf-8")
+    target_file = nested_directory / "module.py"
+
+    found = find_pyproject_configuring_tool(target_file, RUFF_TOOL_TABLE_NAME)
+
+    assert found == owning_pyproject
+
+
+def test_find_pyproject_configuring_tool_skips_pyproject_without_the_table(
+    tmp_path: Path,
+) -> None:
+    outer_root = tmp_path / "outer"
+    inner_root = outer_root / "inner"
+    inner_root.mkdir(parents=True)
+    outer_pyproject = outer_root / "pyproject.toml"
+    outer_pyproject.write_text("[tool.mypy]\nignore_missing_imports = true\n", encoding="utf-8")
+    (inner_root / "pyproject.toml").write_text("[project]\nname = 'inner'\n", encoding="utf-8")
+    target_file = inner_root / "module.py"
+
+    found = find_pyproject_configuring_tool(target_file, MYPY_TOOL_TABLE_NAME)
+
+    assert found == outer_pyproject
+
+
+def test_find_pyproject_configuring_tool_is_table_specific(tmp_path: Path) -> None:
+    project_root = tmp_path / "mypy_only"
+    project_root.mkdir()
+    (project_root / "pyproject.toml").write_text(
+        "[tool.mypy]\nignore_missing_imports = true\n", encoding="utf-8"
+    )
+    target_file = project_root / "module.py"
+
+    assert find_pyproject_configuring_tool(target_file, MYPY_TOOL_TABLE_NAME) is not None
+    assert find_pyproject_configuring_tool(target_file, RUFF_TOOL_TABLE_NAME) is None
+
+
+def test_find_pyproject_configuring_tool_returns_none_when_no_match(tmp_path: Path) -> None:
+    isolated_directory = tmp_path / "isolated"
+    isolated_directory.mkdir()
+    target_file = isolated_directory / "module.py"
+
+    assert find_pyproject_configuring_tool(target_file, RUFF_TOOL_TABLE_NAME) is None
+
+
+def test_find_pyproject_configuring_tool_treats_malformed_toml_as_no_match(
+    tmp_path: Path,
+) -> None:
+    project_root = tmp_path / "broken"
+    project_root.mkdir()
+    (project_root / "pyproject.toml").write_text("[tool.ruff\nbroken = true\n", encoding="utf-8")
+    target_file = project_root / "module.py"
+
+    assert find_pyproject_configuring_tool(target_file, RUFF_TOOL_TABLE_NAME) is None