invar-tools 1.17.19__tar.gz → 1.17.21__tar.gz

{invar_tools-1.17.19 → invar_tools-1.17.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: invar-tools
-Version: 1.17.19
+Version: 1.17.21
 Summary: AI-native software engineering tools with design-by-contract verification
 Project-URL: Homepage, https://github.com/tefx/invar
 Project-URL: Documentation, https://github.com/tefx/invar#readme
@@ -23,13 +23,14 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.11
 Requires-Dist: crosshair-tool>=0.0.60
 Requires-Dist: hypothesis>=6.0
-Requires-Dist: invar-runtime>=1.0
+Requires-Dist: invar-runtime>=1.3.0
 Requires-Dist: jedi>=0.19
 Requires-Dist: jinja2>=3.0
 Requires-Dist: markdown-it-py>=3.0
 Requires-Dist: mcp>=1.0
 Requires-Dist: pre-commit>=3.0
 Requires-Dist: pydantic>=2.0
+Requires-Dist: pytest>=7.0
 Requires-Dist: questionary>=2.0
 Requires-Dist: returns>=0.20
 Requires-Dist: rich>=13.0
@@ -38,7 +39,6 @@ Provides-Extra: dev
 Requires-Dist: coverage[toml]>=7.0; extra == 'dev'
 Requires-Dist: mypy>=1.0; extra == 'dev'
 Requires-Dist: pytest-cov>=4.0; extra == 'dev'
-Requires-Dist: pytest>=7.0; extra == 'dev'
 Requires-Dist: ruff>=0.1; extra == 'dev'
 Description-Content-Type: text/markdown
 

{invar_tools-1.17.19 → invar_tools-1.17.21}/pyproject.toml

@@ -15,7 +15,7 @@ ignore-vcs = true
 
 [project]
 name = "invar-tools"
-version = "1.17.19"
+version = "1.17.21"
 description = "AI-native software engineering tools with design-by-contract verification"
 readme = "README.md"
 license = "GPL-3.0-or-later"
@@ -37,7 +37,7 @@ classifiers = [
 
 dependencies = [
     # Runtime contracts (DX-21: Package split)
-    "invar-runtime>=1.0",
+    "invar-runtime>=1.3.0",
     # CLI and output
     "typer>=0.9",
     "rich>=13.0",
@@ -48,6 +48,7 @@ dependencies = [
     "pre-commit>=3.0",
     "markdown-it-py>=3.0",  # DX-76: Markdown document parsing
     # Verification (DX-12: Hypothesis as CrossHair fallback)
+    "pytest>=7.0",
     "hypothesis>=6.0",
     "crosshair-tool>=0.0.60",
     # MCP server (DX-16: Agent tool enforcement)
@@ -60,7 +61,6 @@ dependencies = [
 
 [project.optional-dependencies]
 dev = [
-    "pytest>=7.0",
     "pytest-cov>=4.0",
     "mypy>=1.0",
     "ruff>=0.1",

{invar_tools-1.17.19 → invar_tools-1.17.21}/src/invar/shell/commands/guard.py

@@ -6,6 +6,8 @@ Shell module: handles user interaction and file I/O.
 
 from __future__ import annotations
 
+import os
+import sys
 from pathlib import Path
 
 import typer
@@ -17,7 +19,7 @@ from invar import __version__
 from invar.core.models import GuardReport, RuleConfig
 from invar.core.rules import check_all_rules
 from invar.core.utils import get_exit_code
-from invar.shell.config import find_project_root, load_config
+from invar.shell.config import find_project_root, find_pyproject_root, load_config
 from invar.shell.fs import scan_project
 from invar.shell.guard_output import output_agent, output_rich
 
@@ -225,7 +227,27 @@ def guard(
             console.print(f"[red]Error:[/red] {path} is not a Python file")
             raise typer.Exit(1)
         single_file = path.resolve()
-        path = find_project_root(path)
+
+    pyproject_root = find_pyproject_root(single_file if single_file else path)
+    if pyproject_root is None:
+        console.print(
+            "[red]Error:[/red] pyproject.toml not found (searched upward from the target path)"
+        )
+        raise typer.Exit(1)
+    path = pyproject_root
+
+    from invar.shell.subprocess_env import get_uvx_respawn_command
+
+    cmd = get_uvx_respawn_command(
+        project_root=path,
+        argv=sys.argv[1:],
+        tool_name=Path(sys.argv[0]).name,
+        invar_tools_version=__version__,
+    )
+    if cmd is not None:
+        env = os.environ.copy()
+        env["INVAR_UVX_RESPAWNED"] = "1"
+        os.execvpe(cmd[0], cmd, env)
 
     # Load and configure
     config_result = load_config(path)
@@ -373,6 +395,7 @@ def guard(
 
         # Phase 1: Doctests (DX-37: with optional coverage)
         doctest_passed, doctest_output, doctest_coverage = run_doctests_phase(
+            path,
             checked_files,
             explain,
             timeout=config.timeout_doctest,
@@ -393,6 +416,7 @@ def guard(
 
         # Phase 3: Hypothesis property tests (DX-37: with optional coverage)
         property_passed, property_output, property_coverage = run_property_tests_phase(
+            path,
             checked_files,
             doctest_passed,
             static_exit_code,

{invar_tools-1.17.19 → invar_tools-1.17.21}/src/invar/shell/config.py

@@ -39,11 +39,27 @@ class ModuleType(Enum):
 
 
 # I/O libraries that indicate Shell module (for AST import checking)
-_IO_LIBRARIES = frozenset([
-    "os", "sys", "subprocess", "pathlib", "shutil", "io", "socket",
-    "requests", "aiohttp", "httpx", "urllib", "sqlite3", "psycopg2",
-    "pymongo", "sqlalchemy", "typer", "click",
-])
+_IO_LIBRARIES = frozenset(
+    [
+        "os",
+        "sys",
+        "subprocess",
+        "pathlib",
+        "shutil",
+        "io",
+        "socket",
+        "requests",
+        "aiohttp",
+        "httpx",
+        "urllib",
+        "sqlite3",
+        "psycopg2",
+        "pymongo",
+        "sqlalchemy",
+        "typer",
+        "click",
+    ]
+)
 
 # Contract decorator names
 _CONTRACT_DECORATORS = frozenset(["pre", "post", "invariant"])
@@ -226,6 +242,7 @@ def auto_detect_module_type(source: str, file_path: str = "") -> ModuleType:
     # Unknown: neither clear pattern
     return ModuleType.UNKNOWN
 
+
 if TYPE_CHECKING:
     from pathlib import Path
 
@@ -268,6 +285,20 @@ def _find_config_source(project_root: Path) -> Result[tuple[Path | None, ConfigS
 
 
 # @shell_complexity: Project root discovery requires checking multiple markers
+def find_pyproject_root(start_path: "Path") -> "Path | None":  # noqa: UP037
+    from pathlib import Path
+
+    current = Path(start_path).resolve()
+    if current.is_file():
+        current = current.parent
+
+    for parent in [current, *current.parents]:
+        if (parent / "pyproject.toml").exists():
+            return parent
+
+    return None
+
+
 def find_project_root(start_path: "Path") -> "Path":  # noqa: UP037
     """
     Find project root by walking up from start_path looking for config files.
@@ -492,6 +523,7 @@ def classify_file(
     else:
         # Log warning about config error, use defaults
         import logging
+
         logging.getLogger(__name__).debug(
             "Pattern classification failed: %s, using defaults", pattern_result.failure()
         )
@@ -503,6 +535,7 @@ def classify_file(
     else:
         # Log warning about config error, use defaults
         import logging
+
         logging.getLogger(__name__).debug(
             "Path classification failed: %s, using defaults", path_result.failure()
         )

{invar_tools-1.17.19 → invar_tools-1.17.21}/src/invar/shell/git.py

@@ -7,13 +7,10 @@ Shell module: handles git I/O for changed file detection.
 from __future__ import annotations
 
 import subprocess
-from typing import TYPE_CHECKING
+from pathlib import Path
 
 from returns.result import Failure, Result, Success
 
-if TYPE_CHECKING:
-    from pathlib import Path
-
 
 def _run_git(args: list[str], cwd: Path) -> Result[str, str]:
     """Run a git command and return stdout."""
@@ -49,27 +46,29 @@ def get_changed_files(project_root: Path) -> Result[set[Path], str]:
         >>> isinstance(result, (Success, Failure))
         True
     """
-    # Verify git repo
     check = _run_git(["rev-parse", "--git-dir"], project_root)
     if isinstance(check, Failure):
         return Failure(f"Not a git repository: {project_root}")
 
+    repo_root_result = _run_git(["rev-parse", "--show-toplevel"], project_root)
+    if isinstance(repo_root_result, Failure):
+        return Failure(repo_root_result.failure())
+
+    repo_root = Path(repo_root_result.unwrap().strip())
+
     changed: set[Path] = set()
 
-    # Staged changes
     staged = _run_git(["diff", "--cached", "--name-only"], project_root)
     if isinstance(staged, Success):
-        changed.update(_parse_py_files(staged.unwrap(), project_root))
+        changed.update(_parse_py_files(staged.unwrap(), repo_root))
 
-    # Unstaged changes
     unstaged = _run_git(["diff", "--name-only"], project_root)
     if isinstance(unstaged, Success):
-        changed.update(_parse_py_files(unstaged.unwrap(), project_root))
+        changed.update(_parse_py_files(unstaged.unwrap(), repo_root))
 
-    # Untracked files
     untracked = _run_git(["ls-files", "--others", "--exclude-standard"], project_root)
     if isinstance(untracked, Success):
-        changed.update(_parse_py_files(untracked.unwrap(), project_root))
+        changed.update(_parse_py_files(untracked.unwrap(), repo_root))
 
     return Success(changed)
 

{invar_tools-1.17.19 → invar_tools-1.17.21}/src/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_tools-1.17.19 → invar_tools-1.17.21}/src/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]")