invar-tools 1.17.12__py3-none-any.whl → 1.17.24__py3-none-any.whl

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, project_root=root)
+
     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))
@@ -180,15 +218,56 @@ def _accumulate_report(
     combined_report.errors.extend(file_report.errors)
 
 
-def _import_module_from_path(file_path: Path) -> object | None:
+# @shell_complexity: BUG-57 fix requires package hierarchy setup for relative imports
+def _import_module_from_path(file_path: Path, project_root: Path | None = None) -> object | None:
     """
     Import a Python module from a file path.
 
+    BUG-57: Properly handles relative imports by setting up package context.
+
     Returns None if import fails.
     """
     try:
-        module_name = file_path.stem
-        spec = importlib.util.spec_from_file_location(module_name, file_path)
+        # Calculate the full module name from project root
+        if project_root and file_path.is_relative_to(project_root):
+            # Convert path to module name: my_package/main.py -> my_package.main
+            relative = file_path.relative_to(project_root)
+            parts = list(relative.with_suffix("").parts)
+            module_name = ".".join(parts)
+        else:
+            module_name = file_path.stem
+
+        # Ensure project root is in sys.path for relative imports
+        if project_root:
+            root_str = str(project_root)
+            if root_str not in sys.path:
+                sys.path.insert(0, root_str)
+
+        # For packages with relative imports, we need to set up parent packages first
+        if "." in module_name:
+            # Import parent packages first
+            parts = module_name.split(".")
+            for i in range(1, len(parts)):
+                parent_name = ".".join(parts[:i])
+                if parent_name not in sys.modules:
+                    parent_path = project_root / "/".join(parts[:i]) if project_root else None
+                    if parent_path and (parent_path / "__init__.py").exists():
+                        parent_spec = importlib.util.spec_from_file_location(
+                            parent_name,
+                            parent_path / "__init__.py",
+                            submodule_search_locations=[str(parent_path)],
+                        )
+                        if parent_spec and parent_spec.loader:
+                            parent_module = importlib.util.module_from_spec(parent_spec)
+                            sys.modules[parent_name] = parent_module
+                            parent_spec.loader.exec_module(parent_module)
+
+        # Now import the target module
+        spec = importlib.util.spec_from_file_location(
+            module_name,
+            file_path,
+            submodule_search_locations=[str(file_path.parent)],
+        )
         if spec is None or spec.loader is None:
             return None
 
@@ -222,26 +301,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 +345,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,15 +82,94 @@ 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
 
 
+# BUG-56: Detect Literal types that CrossHair cannot handle
+# @shell_orchestration: Pre-filter for CrossHair verification
+# @shell_complexity: AST traversal for type annotation analysis
+def has_literal_in_contracted_functions(source: str) -> bool:
+    """Check if any contracted function uses Literal types in parameters.
+
+    CrossHair cannot symbolically execute Literal types and silently skips them.
+    This function detects such cases for pre-filtering and warning.
+    """
+    # Fast path: no Literal import
+    if "Literal" not in source:
+        return False
+
+    # Fast path: no contracts
+    if "@pre" not in source and "@post" not in source:
+        return False
+
+    try:
+        import ast
+
+        tree = ast.parse(source)
+    except SyntaxError:
+        return False  # Can't analyze, don't skip
+
+    contract_decorators = {"pre", "post"}
+
+    def has_contract(node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
+        for dec in node.decorator_list:
+            if isinstance(dec, ast.Call):
+                func = dec.func
+                if isinstance(func, ast.Name) and func.id in contract_decorators:
+                    return True
+                if isinstance(func, ast.Attribute) and func.attr in contract_decorators:
+                    return True
+        return False
+
+    def annotation_uses_literal(annotation: ast.expr | None) -> bool:
+        """Check if annotation contains Literal type."""
+        if annotation is None:
+            return False
+
+        # Direct Literal["..."]
+        if isinstance(annotation, ast.Subscript):
+            value = annotation.value
+            if isinstance(value, ast.Name) and value.id == "Literal":
+                return True
+            if isinstance(value, ast.Attribute) and value.attr == "Literal":
+                return True
+            # Check nested (e.g., Optional[Literal["..."]])
+            if annotation_uses_literal(annotation.slice):
+                return True
+            if annotation_uses_literal(value):
+                return True
+
+        # Union types
+        if isinstance(annotation, ast.BinOp):  # X | Y syntax
+            return annotation_uses_literal(annotation.left) or annotation_uses_literal(
+                annotation.right
+            )
+
+        # Tuple of types (for Subscript.slice)
+        if isinstance(annotation, ast.Tuple):
+            return any(annotation_uses_literal(elt) for elt in annotation.elts)
+
+        return False
+
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            if has_contract(node):
+                # Check all parameter annotations
+                for arg in node.args.args + node.args.posonlyargs + node.args.kwonlyargs:
+                    if annotation_uses_literal(arg.annotation):
+                        return True
+                # Check *args and **kwargs
+                if node.args.vararg and annotation_uses_literal(node.args.vararg.annotation):
+                    return True
+                if node.args.kwarg and annotation_uses_literal(node.args.kwarg.annotation):
+                    return True
+
+    return False
+
+
 # ============================================================
 # DX-13: Single File Verification (for parallel execution)
 # ============================================================
@@ -102,6 +181,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 +213,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)
@@ -157,6 +238,23 @@ def _verify_single_file(
             # symbolically execute C extensions like ast.parse()
             # Check both stdout and stderr for error patterns
             output = result.stdout + "\n" + result.stderr
+
+            # BUG-56: Detect Literal type errors (CrossHair limitation)
+            literal_errors = [
+                "Cannot instantiate typing.Literal",
+                "CrosshairUnsupported",
+            ]
+            is_literal_error = any(err in output for err in literal_errors)
+
+            if is_literal_error:
+                return {
+                    "file": file_path,
+                    "status": CrossHairStatus.SKIPPED,
+                    "time_ms": elapsed_ms,
+                    "reason": "Literal type not supported (tested by Hypothesis)",
+                    "stdout": output,
+                }
+
             execution_errors = [
                 "TypeError:",
                 "AttributeError:",
@@ -222,6 +320,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).
 
@@ -298,6 +397,17 @@ def run_crosshair_parallel(
                     }
                 )
                 continue
+
+            # BUG-56: Check for Literal types that CrossHair cannot handle
+            if has_literal_in_contracted_functions(source):
+                cached_results.append(
+                    {
+                        "file": str(py_file),
+                        "status": CrossHairStatus.SKIPPED,
+                        "reason": "Literal type not supported (tested by Hypothesis)",
+                    }
+                )
+                continue
         except OSError:
             pass  # Include file anyway
 
@@ -324,6 +434,7 @@ def run_crosshair_parallel(
     verified_files: list[str] = []
     failed_files: list[str] = []
     all_counterexamples: list[str] = []
+    skipped_at_runtime: list[dict] = []  # BUG-56: Track runtime skips with reasons
     total_time_ms = 0
 
     if max_workers > 1 and len(files_to_verify) > 1:
@@ -331,7 +442,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
             }
@@ -346,6 +462,7 @@ def run_crosshair_parallel(
                         verified_files,
                         failed_files,
                         all_counterexamples,
+                        skipped_at_runtime,
                         cache,
                     )
                     total_time_ms += result.get("time_ms", 0)
@@ -355,7 +472,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,
@@ -363,14 +484,17 @@ def run_crosshair_parallel(
                 verified_files,
                 failed_files,
                 all_counterexamples,
+                skipped_at_runtime,
                 cache,
             )
             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
+
+    # BUG-56: Combine pre-filtered skipped and runtime skipped
+    all_skipped = [r["file"] for r in cached_results if r.get("status") == "skipped"]
+    all_skipped.extend([r["file"] for r in skipped_at_runtime])
 
     return Success(
         {
@@ -378,7 +502,8 @@ def run_crosshair_parallel(
             "verified": verified_files,
             "failed": failed_files,
             "cached": [r["file"] for r in cached_results if r.get("status") == "cached"],
-            "skipped": [r["file"] for r in cached_results if r.get("status") == "skipped"],
+            "skipped": all_skipped,
+            "skipped_reasons": skipped_at_runtime,  # BUG-56: Include reasons
             "counterexamples": all_counterexamples,
             "files": [str(f) for f in py_files],
             "files_verified": len(files_to_verify),
@@ -397,6 +522,7 @@ def _process_verification_result(
     verified_files: list[str],
     failed_files: list[str],
     all_counterexamples: list[str],
+    skipped_at_runtime: list[dict],  # BUG-56: Track runtime skips
     cache: ProveCache | None,
 ) -> None:
     """Process a single verification result."""
@@ -418,6 +544,14 @@ def _process_verification_result(
         failed_files.append(f"{file_path} (timeout)")
     elif status == CrossHairStatus.ERROR:
         failed_files.append(f"{file_path} ({result.get('error', 'unknown error')})")
+    elif status == CrossHairStatus.SKIPPED:
+        # BUG-56: Track skipped files with reasons (e.g., Literal type)
+        skipped_at_runtime.append(
+            {
+                "file": str(file_path),
+                "reason": result.get("reason", "unsupported"),
+            }
+        )
 
 
 # ============================================================

invar/shell/prove/guard_ts.py

@@ -374,14 +374,28 @@ def _check_tool_available(tool: str, check_args: list[str]) -> bool:
 # =============================================================================
 
 
+def _is_invar_package_dir(package_dir: Path, package_name: str) -> bool:
+    package_json = package_dir / "package.json"
+    if not package_json.exists():
+        return False
+
+    try:
+        data = json.loads(package_json.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return False
+
+    return data.get("name") == f"@invar/{package_name}"
+
+
 # @shell_complexity: Path discovery with fallback logic
 def _get_invar_package_cmd(package_name: str, project_path: Path) -> list[str]:
     """Get command to run an @invar/* package.
 
     Priority order:
-    1. Embedded tools (pip install invar-tools includes these)
-    2. Local development (typescript/packages/*/dist/ in Invar repo)
-    3. npx fallback (if published to npm)
+    1. Project-local override (typescript/packages/* or packages/*)
+    2. Embedded tools (pip install invar-tools includes these)
+    3. Local monorepo lookup (walk up)
+    4. npx fallback (if published to npm)
 
     Args:
         package_name: Package name without @invar/ prefix (e.g., "ts-analyzer")
@@ -390,7 +404,18 @@ def _get_invar_package_cmd(package_name: str, project_path: Path) -> list[str]:
     Returns:
         Command list for subprocess.run
     """
-    # Priority 1: Embedded tools (from pip install)
+    # Resolve to absolute path to avoid path doubling issues
+    resolved_path = project_path.resolve()
+
+    local_cli = resolved_path / "typescript" / "packages" / package_name / "dist" / "cli.js"
+    if local_cli.exists() and _is_invar_package_dir(local_cli.parent.parent, package_name):
+        return ["node", str(local_cli)]
+
+    local_cli = resolved_path / "packages" / package_name / "dist" / "cli.js"
+    if local_cli.exists() and _is_invar_package_dir(local_cli.parent.parent, package_name):
+        return ["node", str(local_cli)]
+
+    # Priority 2: Embedded tools (from pip install)
     try:
         from invar.node_tools import get_tool_path
 
@@ -399,16 +424,13 @@ def _get_invar_package_cmd(package_name: str, project_path: Path) -> list[str]:
     except ImportError:
         pass  # node_tools module not available
 
-    # Priority 2: Local development setup (Invar repo itself)
-    local_cli = project_path / f"typescript/packages/{package_name}/dist/cli.js"
-    if local_cli.exists():
-        return ["node", str(local_cli)]
-
-    # Priority 2b: Walk up to find the Invar root (monorepo setup)
-    check_path = project_path
+    # Priority 3b: Walk up to find the Invar root (monorepo setup)
+    # This is intentional for monorepo development - allows running from subdirectories
+    # Only searches up to 5 levels to limit exposure
+    check_path = resolved_path
     for _ in range(5):  # Max 5 levels up
         candidate = check_path / f"typescript/packages/{package_name}/dist/cli.js"
-        if candidate.exists():
+        if candidate.exists() and _is_invar_package_dir(candidate.parent.parent, package_name):
             return ["node", str(candidate)]
         parent = check_path.parent
         if parent == check_path:
@@ -439,7 +461,7 @@ def run_ts_analyzer(project_path: Path) -> Result[dict, str]:
     try:
         cmd = _get_invar_package_cmd("ts-analyzer", project_path)
         result = subprocess.run(
-            [*cmd, str(project_path), "--json"],
+            [*cmd, str(project_path.resolve()), "--json"],
             capture_output=True,
             text=True,
             timeout=60,
@@ -456,7 +478,7 @@ def run_ts_analyzer(project_path: Path) -> Result[dict, str]:
                 # Fall back to running without --json flag for human-readable summary
                 try:
                     summary_result = subprocess.run(
-                        [*cmd, str(project_path)],
+                        [*cmd, str(project_path.resolve())],
                         capture_output=True,
                         text=True,
                         timeout=60,
@@ -553,7 +575,7 @@ def run_quick_check(project_path: Path) -> Result[dict, str]:
     try:
         cmd = _get_invar_package_cmd("quick-check", project_path)
         result = subprocess.run(
-            [*cmd, str(project_path), "--json"],
+            [*cmd, str(project_path.resolve()), "--json"],
             capture_output=True,
             text=True,
             timeout=30,  # Quick check should be fast
@@ -750,7 +772,8 @@ def run_eslint(project_path: Path) -> Result[list[TypeScriptViolation], str]:
     try:
         # Get command for @invar/eslint-plugin (embedded or local dev)
         cmd = _get_invar_package_cmd("eslint-plugin", project_path)
-        cmd.append(str(project_path))  # Add project path as argument
+        # Resolve path to absolute to avoid path doubling in subprocess
+        cmd.append(str(project_path.resolve()))  # Add project path as argument
 
         # Use temp file to avoid subprocess 64KB buffer limit
         # ESLint output can be large for big projects
@@ -805,7 +828,6 @@ def run_eslint(project_path: Path) -> Result[list[TypeScriptViolation], str]:
             if result.returncode != 0 and result.stderr:
                 return Failure(f"ESLint error: {result.stderr[:200]}")
             return Failure("ESLint output parsing failed: JSON decode error")
-            return Failure("ESLint output parsing failed: JSON decode error")
 
         return Success(violations)