claude-dev-env 2.2.1 → 2.4.0

package/hooks/validators/mypy_integration.py

@@ -4,19 +4,33 @@ import contextlib
 import subprocess
 import sys
 import tempfile
-import tomllib
 from collections.abc import Iterator
 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 (
+        ancestor_directories,
+        find_pyproject_configuring_tool,
+    )
+except ModuleNotFoundError:
+    if _validators_directory not in sys.path:
+        sys.path.insert(0, _validators_directory)
+    from pyproject_config_discovery import (
+        ancestor_directories,
+        find_pyproject_configuring_tool,
+    )
+
 try:
     from hooks_constants.mypy_integration_constants import (
         GIT_DIRECTORY_NAME,
         PYPROJECT_FILENAME,
         PYTHON_SOURCE_SUFFIX,
     )
+    from hooks_constants.pyproject_config_discovery_constants import MYPY_TOOL_TABLE_NAME
 except ModuleNotFoundError:
     if _hooks_directory not in sys.path:
         sys.path.insert(0, _hooks_directory)
@@ -25,6 +39,7 @@ except ModuleNotFoundError:
         PYPROJECT_FILENAME,
         PYTHON_SOURCE_SUFFIX,
     )
+    from hooks_constants.pyproject_config_discovery_constants import MYPY_TOOL_TABLE_NAME
 
 
 @dataclass
@@ -48,38 +63,6 @@ def check_mypy_available() -> bool:
         return False
 
 
-def _pyproject_contains_tool_mypy(pyproject_path: Path) -> bool:
-    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", {})
-    return isinstance(tool_table, dict) and "mypy" in tool_table
-
-
-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 ancestor walks below start 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 find_pyproject_with_mypy_config(starting_file: Path) -> Path | None:
     """Walk up from a starting file to locate a pyproject.toml that configures mypy.
 
@@ -97,12 +80,7 @@ def find_pyproject_with_mypy_config(starting_file: Path) -> Path | None:
         table, or ``None`` when no such file exists between ``starting_file``
         and the filesystem root.
     """
-    pyproject_filename_for_lookup = PYPROJECT_FILENAME
-    for each_candidate_directory in _ancestor_directories(starting_file):
-        candidate_pyproject = each_candidate_directory / pyproject_filename_for_lookup
-        if candidate_pyproject.is_file() and _pyproject_contains_tool_mypy(candidate_pyproject):
-            return candidate_pyproject
-    return None
+    return find_pyproject_configuring_tool(starting_file, MYPY_TOOL_TABLE_NAME)
 
 
 def find_module_resolution_root(starting_file: Path) -> Path | None:
@@ -127,7 +105,7 @@ def find_module_resolution_root(starting_file: Path) -> Path | None:
     """
     git_entry_name = GIT_DIRECTORY_NAME
     pyproject_filename = PYPROJECT_FILENAME
-    for each_candidate_directory in _ancestor_directories(starting_file):
+    for each_candidate_directory in ancestor_directories(starting_file):
         has_git_entry = (each_candidate_directory / git_entry_name).exists()
         has_pyproject = (each_candidate_directory / pyproject_filename).is_file()
         if has_git_entry or has_pyproject:
@@ -171,7 +149,7 @@ def mypy_working_directory(all_py_files: list[str]) -> Iterator[str]:
         yield isolated_directory
 
 
-def _mypy_config_argument(all_py_files: list[str]) -> list[str]:
+def _native_mypy_config_argument(all_py_files: list[str]) -> list[str]:
     """Return the ``--config-file`` argument for the first file with a mypy config."""
     for each_py_file in all_py_files:
         discovered_pyproject = find_pyproject_with_mypy_config(Path(each_py_file))
@@ -180,9 +158,39 @@ def _mypy_config_argument(all_py_files: list[str]) -> list[str]:
     return []
 
 
-def _run_mypy_subprocess(all_py_files: list[str]) -> subprocess.CompletedProcess[str]:
+def _mypy_config_argument(
+    all_py_files: list[str], config_source_path: Path | None
+) -> list[str]:
+    """Return the ``--config-file`` argument, resolved from the original path when given.
+
+    ::
+
+        config_source_path resolves .../hooks/pyproject.toml
+            -> ["--config-file", ".../hooks/pyproject.toml"]
+        config_source_path given, no [tool.mypy] up-tree -> [] (native discovery)
+        config_source_path None -> native per-file discovery over all_py_files
+
+    Args:
+        all_py_files: The resolved paths mypy will check.
+        config_source_path: The original target path the staged copy stands in
+            for, or ``None`` for a native multi-file run.
+
+    Returns:
+        The ``--config-file`` argument vector, empty when no config resolves.
+    """
+    if config_source_path is None:
+        return _native_mypy_config_argument(all_py_files)
+    resolved_pyproject = find_pyproject_with_mypy_config(config_source_path)
+    if resolved_pyproject is not None:
+        return ["--config-file", str(resolved_pyproject)]
+    return _native_mypy_config_argument(all_py_files)
+
+
+def _run_mypy_subprocess(
+    all_py_files: list[str], config_source_path: Path | None
+) -> subprocess.CompletedProcess[str]:
     """Run mypy over *all_py_files* from each file's own project root."""
-    config_argument = _mypy_config_argument(all_py_files)
+    config_argument = _mypy_config_argument(all_py_files, config_source_path)
     with mypy_working_directory(all_py_files) as working_directory:
         return subprocess.run(
             ["mypy", *config_argument, "--ignore-missing-imports", "--no-error-summary"]
@@ -194,24 +202,29 @@ def _run_mypy_subprocess(all_py_files: list[str]) -> subprocess.CompletedProcess
         )
 
 
-def run_mypy_check(files: list[Path]) -> MypyResult:
-    """Run mypy on files."""
-    if not files:
+def run_mypy_check(
+    all_files: list[Path], config_source_path: Path | None = None
+) -> MypyResult:
+    """Run mypy on files, resolving config from *config_source_path* when given.
+
+    A given ``config_source_path`` walks ``--config-file`` up from the original
+    target rather than the staged copy's own ancestors.
+    """
+    if not all_files:
         return MypyResult(passed=True, output="No files to check", error_count=0)
 
     if not check_mypy_available():
         return MypyResult(passed=True, output="Mypy not installed - skipping", error_count=0)
 
-    python_source_suffix = PYTHON_SOURCE_SUFFIX
     all_py_files = [
         str(each_file.resolve())
-        for each_file in files
-        if each_file.suffix == python_source_suffix
+        for each_file in all_files
+        if each_file.suffix == PYTHON_SOURCE_SUFFIX
     ]
     if not all_py_files:
         return MypyResult(passed=True, output="No Python files", error_count=0)
 
-    completed_process = _run_mypy_subprocess(all_py_files)
+    completed_process = _run_mypy_subprocess(all_py_files, config_source_path)
     error_count = completed_process.stdout.count(": error:")
 
     return MypyResult(

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: