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

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
 
@@ -190,12 +192,28 @@ def guard(
         ts_result = run_typescript_guard(path if path.is_dir() else find_project_root(path))
         match ts_result:
             case Success(result):
-                import json as json_mod
+                if human:
+                    # Human-readable Rich output
+                    from invar.shell.prove.guard_ts import format_typescript_guard_v2
+
+                    output = format_typescript_guard_v2(result)
+                    console.print(f"[bold]TypeScript Guard[/bold] ({project_language})")
+                    if result.status == "passed":
+                        console.print("[green]✓ PASSED[/green]")
+                    elif result.status == "skipped":
+                        console.print("[yellow]⚠ SKIPPED[/yellow] (no TypeScript tools available)")
+                    else:
+                        console.print(f"[red]✗ FAILED[/red] ({result.error_count} errors)")
+                        for v in result.violations[:10]:  # Show first 10
+                            console.print(f"  {v.file}:{v.line}: [{v.severity}] {v.message}")
+                else:
+                    # JSON output for agents
+                    import json as json_mod
 
-                from invar.shell.prove.guard_ts import format_typescript_guard_v2
+                    from invar.shell.prove.guard_ts import format_typescript_guard_v2
 
-                output = format_typescript_guard_v2(result)
-                console.print(json_mod.dumps(output, indent=2))
+                    output = format_typescript_guard_v2(result)
+                    console.print(json_mod.dumps(output, indent=2))
                 raise typer.Exit(0 if result.status == "passed" else 1)
             case Failure(err):
                 console.print(f"[red]Error:[/red] {err}")
@@ -209,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)
@@ -357,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,
@@ -377,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/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.
@@ -335,34 +366,44 @@ def load_config(project_root: Path) -> Result[RuleConfig, str]:
     3. .invar/config.toml [guard]
     4. Built-in defaults
 
+    If pyproject.toml exists but has no [tool.invar.guard] section,
+    continues to check other sources (fallback behavior).
+
     Args:
         project_root: Path to project root directory
 
     Returns:
         Result containing RuleConfig or error message
     """
-    find_result = _find_config_source(project_root)
-    if isinstance(find_result, Failure):
-        return find_result
-    config_path, source = find_result.unwrap()
+    # Try each config source in priority order
+    sources_to_try: list[tuple[Path, ConfigSource]] = []
 
-    if source == "default":
-        return Success(RuleConfig())
+    pyproject = project_root / "pyproject.toml"
+    if pyproject.exists():
+        sources_to_try.append((pyproject, "pyproject"))
 
-    assert config_path is not None  # source != "default" guarantees path exists
-    result = _read_toml(config_path)
+    invar_toml = project_root / "invar.toml"
+    if invar_toml.exists():
+        sources_to_try.append((invar_toml, "invar"))
 
-    if isinstance(result, Failure):
-        return result
+    invar_config = project_root / ".invar" / "config.toml"
+    if invar_config.exists():
+        sources_to_try.append((invar_config, "invar_dir"))
 
-    data = result.unwrap()
-    guard_config = extract_guard_section(data, source)
+    # Try each source, fallback if no guard config found
+    for config_path, source in sources_to_try:
+        result = _read_toml(config_path)
+        if isinstance(result, Failure):
+            continue  # Skip unreadable files
 
-    # For pyproject.toml, if no [tool.invar.guard] section, use defaults
-    if source == "pyproject" and not guard_config:
-        return Success(RuleConfig())
+        data = result.unwrap()
+        guard_config = extract_guard_section(data, source)
 
-    return Success(parse_guard_config(guard_config))
+        if guard_config:  # Found valid guard config
+            return Success(parse_guard_config(guard_config))
+
+    # No config found in any source, use defaults
+    return Success(RuleConfig())
 
 
 # Default paths for Core/Shell classification
@@ -492,6 +533,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 +545,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/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/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)
 
-    return result_files
+    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 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
@@ -151,7 +178,24 @@ def run_crosshair_phase(
         return True, {"status": "skipped", "reason": "no files to verify"}
 
     # Only verify Core files (pure logic)
-    core_files = [f for f in checked_files if "core" in str(f)]
+    # BUG-57: Use config-based core detection instead of hardcoded "core" in path
+    from invar.core.utils import matches_path_prefix
+    from invar.shell.config import get_path_classification
+
+    path_result = get_path_classification(path)
+    if isinstance(path_result, Success):
+        core_paths, _ = path_result.unwrap()
+    else:
+        core_paths = ["src/core", "core"]
+
+    def is_core_file(f: Path) -> bool:
+        try:
+            rel = str(f.relative_to(path))
+        except ValueError:
+            rel = str(f)
+        return matches_path_prefix(rel, core_paths)
+
+    core_files = [f for f in checked_files if is_core_file(f)]
     if not core_files:
         return True, {"status": "skipped", "reason": "no core files found"}
 
@@ -176,6 +220,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 +275,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 +295,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,
@@ -286,11 +323,33 @@ def run_property_tests_phase(
         return True, {"status": "skipped", "reason": "no files"}, None
 
     # Only test Core files (with contracts)
-    core_files = [f for f in checked_files if "core" in str(f)]
+    # BUG-57: Use config-based core detection instead of hardcoded "core" in path
+    from invar.core.utils import matches_path_prefix
+    from invar.shell.config import get_path_classification
+
+    path_result = get_path_classification(project_root)
+    if isinstance(path_result, Success):
+        core_paths, _ = path_result.unwrap()
+    else:
+        core_paths = ["src/core", "core"]
+
+    def is_core_file(f: Path) -> bool:
+        try:
+            rel = str(f.relative_to(project_root))
+        except ValueError:
+            rel = str(f)
+        return matches_path_prefix(rel, core_paths)
+
+    core_files = [f for f in checked_files if is_core_file(f)]
     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 +364,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 +429,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 +469,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]")