invar-tools 1.17.18__py3-none-any.whl → 1.17.20__py3-none-any.whl

invar/shell/guard_helpers.py

@@ -36,24 +36,36 @@ def handle_changed_mode(
     if isinstance(changed_result, Failure):
         return Failure(changed_result.failure())
 
-    only_files = changed_result.unwrap()
+    all_files = changed_result.unwrap()
+    only_files = {p for p in all_files if p.is_relative_to(path)}
     if not only_files:
-        return Failure("NO_CHANGES")  # Special marker for "no changes"
+        return Failure("NO_CHANGES")
 
     return Success((only_files, list(only_files)))
 
 
 # @shell_orchestration: Coordinates path classification and file collection
 # @shell_complexity: File collection with path normalization
-def collect_files_to_check(
-    path: Path, checked_files: list[Path]
-) -> list[Path]:
-    """Collect Python files to check when not in --changed mode."""
-    from invar.shell.config import get_path_classification
+def collect_files_to_check(path: Path, checked_files: list[Path]) -> list[Path]:
+    """Collect Python files for runtime phases, honoring exclude_paths."""
+    from invar.shell.config import get_exclude_paths, get_path_classification
+    from invar.shell.fs import _is_excluded
 
     if checked_files:
         return checked_files
 
+    exclude_result = get_exclude_paths(path)
+    exclude_patterns = exclude_result.unwrap() if isinstance(exclude_result, Success) else []
+
+    def _add_py_files_under(root: Path) -> None:
+        for py_file in root.rglob("*.py"):
+            try:
+                rel = str(py_file.relative_to(path))
+            except ValueError:
+                rel = str(py_file)
+            if not _is_excluded(rel, exclude_patterns):
+                result_files.append(py_file)
+
     result_files: list[Path] = []
 
     path_result = get_path_classification(path)
@@ -62,26 +74,33 @@ def collect_files_to_check(
     else:
         core_paths, shell_paths = ["src/core"], ["src/shell"]
 
-    # Scan core/shell paths
     for core_path in core_paths:
         full_path = path / core_path
         if full_path.exists():
-            result_files.extend(full_path.rglob("*.py"))
+            _add_py_files_under(full_path)
 
     for shell_path in shell_paths:
         full_path = path / shell_path
         if full_path.exists():
-            result_files.extend(full_path.rglob("*.py"))
+            _add_py_files_under(full_path)
 
-    # Fallback: scan path directly
     if not result_files and path.exists():
-        result_files.extend(path.rglob("*.py"))
+        _add_py_files_under(path)
+
+    seen: set[str] = set()
+    unique: list[Path] = []
+    for f in result_files:
+        key = str(f)
+        if key not in seen:
+            seen.add(key)
+            unique.append(f)
 
-    return result_files
+    return unique
 
 
 # @shell_orchestration: Coordinates doctest execution via testing module
 def run_doctests_phase(
+    project_root: Path,
     checked_files: list[Path],
     explain: bool,
     timeout: int = 60,
@@ -103,12 +122,20 @@ def run_doctests_phase(
         return True, "", None
 
     doctest_result = run_doctests_on_files(
-        checked_files, verbose=explain, timeout=timeout, collect_coverage=collect_coverage
+        checked_files,
+        verbose=explain,
+        timeout=timeout,
+        collect_coverage=collect_coverage,
+        cwd=project_root,
     )
     if isinstance(doctest_result, Success):
         result_data = doctest_result.unwrap()
         passed = result_data.get("status") in ("passed", "skipped")
-        output = result_data.get("stdout", "")
+        stdout = result_data.get("stdout", "")
+        stderr = result_data.get("stderr", "")
+        output = stdout
+        if not passed and stderr:
+            output = f"{stdout}\n{stderr}" if stdout else stderr
         # DX-37: Return coverage data if collected
         coverage_data = {"collected": result_data.get("coverage_collected", False)}
         return passed, output, coverage_data if collect_coverage else None
@@ -176,6 +203,7 @@ def run_crosshair_phase(
         cache=cache,
         timeout=timeout,
         per_condition_timeout=per_condition_timeout,
+        project_root=path,
     )
 
     if isinstance(crosshair_result, Success):
@@ -230,26 +258,17 @@ def output_verification_status(
                 console.print(doctest_output)
 
         # CrossHair results
-        _output_crosshair_status(
-            static_exit_code, doctest_passed, crosshair_output
-        )
+        _output_crosshair_status(static_exit_code, doctest_passed, crosshair_output)
 
         # Property tests results
         if property_output:
-            _output_property_tests_status(
-                static_exit_code, doctest_passed, property_output
-            )
+            _output_property_tests_status(static_exit_code, doctest_passed, property_output)
     else:
         console.print("[dim]⊘ Runtime tests skipped (static errors)[/dim]")
 
     # DX-26: Combined conclusion after all phases
     console.print("-" * 40)
-    all_passed = (
-        static_exit_code == 0
-        and doctest_passed
-        and crosshair_passed
-        and property_passed
-    )
+    all_passed = static_exit_code == 0 and doctest_passed and crosshair_passed and property_passed
     # In strict mode, warnings also cause failure (but exit code already reflects this)
     status = "passed" if all_passed else "failed"
     color = "green" if all_passed else "red"
@@ -259,6 +278,7 @@ def output_verification_status(
 # @shell_orchestration: Coordinates shell module calls for property testing
 # @shell_complexity: Property tests with result aggregation
 def run_property_tests_phase(
+    project_root: Path,
     checked_files: list[Path],
     doctest_passed: bool,
     static_exit_code: int,
@@ -290,7 +310,12 @@ def run_property_tests_phase(
     if not core_files:
         return True, {"status": "skipped", "reason": "no core files"}, None
 
-    result = run_property_tests_on_files(core_files, max_examples, collect_coverage=collect_coverage)
+    result = run_property_tests_on_files(
+        core_files,
+        max_examples,
+        collect_coverage=collect_coverage,
+        project_root=project_root,
+    )
 
     if isinstance(result, Success):
         report, coverage_data = result.unwrap()
@@ -305,15 +330,19 @@ def run_property_tests_phase(
             for r in report.results
             if not r.passed
         ]
-        return report.all_passed(), {
-            "status": "passed" if report.all_passed() else "failed",
-            "functions_tested": report.functions_tested,
-            "functions_passed": report.functions_passed,
-            "functions_failed": report.functions_failed,
-            "total_examples": report.total_examples,
-            "failures": failures,  # DX-26: Structured failure info
-            "errors": report.errors,
-        }, coverage_data
+        return (
+            report.all_passed(),
+            {
+                "status": "passed" if report.all_passed() else "failed",
+                "functions_tested": report.functions_tested,
+                "functions_passed": report.functions_passed,
+                "functions_failed": report.functions_failed,
+                "total_examples": report.total_examples,
+                "failures": failures,  # DX-26: Structured failure info
+                "errors": report.errors,
+            },
+            coverage_data,
+        )
 
     return False, {"status": "error", "error": result.failure()}, None
 
@@ -366,8 +395,8 @@ def _output_property_tests_status(
             # Show reproduction command with seed
             if seed:
                 console.print(
-                    f"    [dim]Reproduce: python -c \"from hypothesis import reproduce_failure; "
-                    f"import {func_name}\" --seed={seed}[/dim]"
+                    f'    [dim]Reproduce: python -c "from hypothesis import reproduce_failure; '
+                    f'import {func_name}" --seed={seed}[/dim]'
                 )
         # Fallback for errors without structured failures
         for error in property_output.get("errors", [])[:5]:
@@ -406,8 +435,7 @@ def _output_crosshair_status(
             if workers > 1:
                 stats += f", {workers} workers"
             console.print(
-                f"[green]✓ CrossHair verified[/green] "
-                f"[dim]({stats}, {time_sec:.1f}s)[/dim]"
+                f"[green]✓ CrossHair verified[/green] [dim]({stats}, {time_sec:.1f}s)[/dim]"
             )
         else:
             console.print("[green]✓ CrossHair verified[/green]")

invar/shell/property_tests.py

@@ -9,28 +9,57 @@ from __future__ import annotations
 
 import importlib.util
 import sys
+from contextlib import contextmanager, suppress
 from typing import TYPE_CHECKING
 
+if TYPE_CHECKING:
+    from pathlib import Path
+
 from returns.result import Failure, Result, Success
 from rich.console import Console
 
-from invar.core.property_gen import (
-    PropertyTestReport,
-    find_contracted_functions,
-    run_property_test,
-)
-
-if TYPE_CHECKING:
-    from pathlib import Path
+from invar.core.property_gen import PropertyTestReport, find_contracted_functions, run_property_test
+from invar.shell.subprocess_env import detect_project_venv, find_site_packages
 
 console = Console()
 
 
+# @shell_orchestration: Temporarily inject venv site-packages for module imports
+@contextmanager
+def _inject_project_site_packages(project_root: Path):
+    venv = detect_project_venv(project_root)
+    site_packages = find_site_packages(venv) if venv is not None else None
+
+    if site_packages is None:
+        yield
+        return
+
+    src_dir = project_root / "src"
+
+    added: list[str] = []
+    if src_dir.exists():
+        src_dir_str = str(src_dir)
+        sys.path.insert(0, src_dir_str)
+        added.append(src_dir_str)
+
+    site_packages_str = str(site_packages)
+    sys.path.insert(0, site_packages_str)
+    added.append(site_packages_str)
+
+    try:
+        yield
+    finally:
+        for p in added:
+            with suppress(ValueError):
+                sys.path.remove(p)
+
+
 # @shell_complexity: Property test orchestration with module import
 def run_property_tests_on_file(
     file_path: Path,
     max_examples: int = 100,
     verbose: bool = False,
+    project_root: Path | None = None,
 ) -> Result[PropertyTestReport, str]:
     """
     Run property tests on all contracted functions in a file.
@@ -66,8 +95,10 @@ def run_property_tests_on_file(
     if not contracted:
         return Success(PropertyTestReport())  # No contracted functions, skip
 
-    # Import the module to get actual function objects
-    module = _import_module_from_path(file_path)
+    root = project_root or file_path.parent
+    with _inject_project_site_packages(root):
+        module = _import_module_from_path(file_path)
+
     if module is None:
         return Failure(f"Could not import module: {file_path}")
 
@@ -105,6 +136,7 @@ def run_property_tests_on_files(
     max_examples: int = 100,
     verbose: bool = False,
     collect_coverage: bool = False,
+    project_root: Path | None = None,
 ) -> Result[tuple[PropertyTestReport, dict | None], str]:
     """
     Run property tests on multiple files.
@@ -122,9 +154,9 @@ def run_property_tests_on_files(
     try:
         import hypothesis  # noqa: F401
     except ImportError:
-        return Success((PropertyTestReport(
-            errors=["Hypothesis not installed (pip install hypothesis)"]
-        ), None))
+        return Success(
+            (PropertyTestReport(errors=["Hypothesis not installed (pip install hypothesis)"]), None)
+        )
 
     combined_report = PropertyTestReport()
     coverage_data = None
@@ -138,7 +170,9 @@ def run_property_tests_on_files(
             source_dirs = list({f.parent for f in files})
             with cov_ctx(source_dirs) as cov:
                 for file_path in files:
-                    result = run_property_tests_on_file(file_path, max_examples, verbose)
+                    result = run_property_tests_on_file(
+                        file_path, max_examples, verbose, project_root=project_root
+                    )
                     _accumulate_report(combined_report, result)
 
                 # Extract coverage after all tests
@@ -151,11 +185,15 @@ def run_property_tests_on_files(
         except ImportError:
             # coverage not installed, run without it
             for file_path in files:
-                result = run_property_tests_on_file(file_path, max_examples, verbose)
+                result = run_property_tests_on_file(
+                    file_path, max_examples, verbose, project_root=project_root
+                )
                 _accumulate_report(combined_report, result)
     else:
         for file_path in files:
-            result = run_property_tests_on_file(file_path, max_examples, verbose)
+            result = run_property_tests_on_file(
+                file_path, max_examples, verbose, project_root=project_root
+            )
             _accumulate_report(combined_report, result)
 
     return Success((combined_report, coverage_data))
@@ -222,26 +260,29 @@ def format_property_test_report(
     import json
 
     if json_output:
-        return json.dumps({
-            "functions_tested": report.functions_tested,
-            "functions_passed": report.functions_passed,
-            "functions_failed": report.functions_failed,
-            "functions_skipped": report.functions_skipped,
-            "total_examples": report.total_examples,
-            "all_passed": report.all_passed(),
-            "results": [
-                {
-                    "function": r.function_name,
-                    "passed": r.passed,
-                    "examples": r.examples_run,
-                    "error": r.error,
-                    "file_path": r.file_path,  # DX-26
-                    "seed": r.seed,  # DX-26
-                }
-                for r in report.results
-            ],
-            "errors": report.errors,
-        }, indent=2)
+        return json.dumps(
+            {
+                "functions_tested": report.functions_tested,
+                "functions_passed": report.functions_passed,
+                "functions_failed": report.functions_failed,
+                "functions_skipped": report.functions_skipped,
+                "total_examples": report.total_examples,
+                "all_passed": report.all_passed(),
+                "results": [
+                    {
+                        "function": r.function_name,
+                        "passed": r.passed,
+                        "examples": r.examples_run,
+                        "error": r.error,
+                        "file_path": r.file_path,  # DX-26
+                        "seed": r.seed,  # DX-26
+                    }
+                    for r in report.results
+                ],
+                "errors": report.errors,
+            },
+            indent=2,
+        )
 
     # Human-readable format
     lines = []
@@ -263,10 +304,16 @@ def format_property_test_report(
     for result in report.results:
         if not result.passed:
             # DX-26: file::function format
-            location = f"{result.file_path}::{result.function_name}" if result.file_path else result.function_name
+            location = (
+                f"{result.file_path}::{result.function_name}"
+                if result.file_path
+                else result.function_name
+            )
             lines.append(f"  [red]✗[/red] {location}")
             if result.error:
-                short_error = result.error[:100] + "..." if len(result.error) > 100 else result.error
+                short_error = (
+                    result.error[:100] + "..." if len(result.error) > 100 else result.error
+                )
                 lines.append(f"      {short_error}")
             if result.seed:
                 lines.append(f"      [dim]Seed: {result.seed}[/dim]")

invar/shell/prove/crosshair.py

@@ -12,7 +12,7 @@ import os
 import subprocess
 import sys
 from concurrent.futures import ProcessPoolExecutor, as_completed
-from pathlib import Path  # noqa: TC003 - used at runtime
+from pathlib import Path
 from typing import TYPE_CHECKING
 
 from returns.result import Failure, Result, Success
@@ -82,10 +82,7 @@ def has_verifiable_contracts(source: str) -> bool:
                     if isinstance(func, ast.Name) and func.id in contract_decorators:
                         return True
                     # @deal.pre(...) or @deal.post(...)
-                    if (
-                        isinstance(func, ast.Attribute)
-                        and func.attr in contract_decorators
-                    ):
+                    if isinstance(func, ast.Attribute) and func.attr in contract_decorators:
                         return True
 
     return False
@@ -102,6 +99,7 @@ def _verify_single_file(
     max_iterations: int = 5,
     timeout: int = 300,
     per_condition_timeout: int = 30,
+    project_root: str | None = None,
 ) -> dict[str, Any]:
     """
     Verify a single file with CrossHair.
@@ -133,13 +131,14 @@ def _verify_single_file(
     ]
 
     try:
-        # DX-52: Inject project venv site-packages for uvx compatibility
+        env_root = Path(project_root) if project_root else None
         result = subprocess.run(
             cmd,
             capture_output=True,
             text=True,
             timeout=timeout,
-            env=build_subprocess_env(),
+            cwd=project_root,
+            env=build_subprocess_env(cwd=env_root),
         )
 
         elapsed_ms = int((time.time() - start_time) * 1000)
@@ -222,6 +221,7 @@ def run_crosshair_parallel(
     cache: ProveCache | None = None,
     timeout: int = 300,
     per_condition_timeout: int = 30,
+    project_root: Path | None = None,
 ) -> Result[dict, str]:
     """Run CrossHair on multiple files in parallel (DX-13).
 
@@ -331,7 +331,12 @@ def run_crosshair_parallel(
         with ProcessPoolExecutor(max_workers=max_workers) as executor:
             futures = {
                 executor.submit(
-                    _verify_single_file, str(f), max_iterations, timeout, per_condition_timeout
+                    _verify_single_file,
+                    str(f.resolve()),
+                    max_iterations,
+                    timeout,
+                    per_condition_timeout,
+                    str(project_root) if project_root else None,
                 ): f
                 for f in files_to_verify
             }
@@ -355,7 +360,11 @@ def run_crosshair_parallel(
         # Sequential execution (single file or max_workers=1)
         for py_file in files_to_verify:
             result = _verify_single_file(
-                str(py_file), max_iterations, timeout, per_condition_timeout
+                str(py_file.resolve()),
+                max_iterations,
+                timeout,
+                per_condition_timeout,
+                str(project_root) if project_root else None,
             )
             _process_verification_result(
                 result,
@@ -368,9 +377,7 @@ def run_crosshair_parallel(
             total_time_ms += result.get("time_ms", 0)
 
     # Determine overall status
-    status = (
-        CrossHairStatus.VERIFIED if not failed_files else CrossHairStatus.COUNTEREXAMPLE
-    )
+    status = CrossHairStatus.VERIFIED if not failed_files else CrossHairStatus.COUNTEREXAMPLE
 
     return Success(
         {

invar/shell/subprocess_env.py

@@ -135,13 +135,17 @@ def build_subprocess_env(cwd: Path | None = None) -> dict[str, str]:
     if site_packages is None:
         return env
 
-    # Prepend to PYTHONPATH (project packages have priority)
     current = env.get("PYTHONPATH", "")
     separator = ";" if os.name == "nt" else ":"
-    if current:
-        env["PYTHONPATH"] = f"{site_packages}{separator}{current}"
-    else:
-        env["PYTHONPATH"] = str(site_packages)
+
+    src_dir = project_root / "src"
+    prefix_parts: list[str] = []
+    if src_dir.exists():
+        prefix_parts.append(str(src_dir))
+    prefix_parts.append(str(site_packages))
+
+    prefix = separator.join(prefix_parts)
+    env["PYTHONPATH"] = f"{prefix}{separator}{current}" if current else prefix
 
     return env