haiv-cli 0.1.0__tar.gz

haiv_cli-0.1.0/.gitignore

@@ -0,0 +1,41 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db

haiv_cli-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Casey Marquis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

haiv_cli-0.1.0/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: haiv-cli
+Version: 0.1.0
+Summary: Seamless management of a collaborative AI team
+Project-URL: Homepage, https://github.com/caseymarquis/haiv
+Project-URL: Repository, https://github.com/caseymarquis/haiv
+Author: Casey Marquis
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.12
+Requires-Dist: haiv-core

haiv_cli-0.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[project]
+name = "haiv-cli"
+version = "0.1.0"
+description = "Seamless management of a collaborative AI team"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.12"
+authors = [
+    { name = "Casey Marquis" }
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+dependencies = [
+    "haiv-core",
+]
+
+[project.scripts]
+hv = "haiv_cli:main"
+
+[tool.uv.sources]
+haiv-core = { workspace = true }
+
+[project.urls]
+Homepage = "https://github.com/caseymarquis/haiv"
+Repository = "https://github.com/caseymarquis/haiv"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/haiv_cli"]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.2",
+    "pytest-xdist>=3.0",
+    "ty",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

haiv_cli-0.1.0/src/haiv_cli/__init__.py

@@ -0,0 +1,318 @@
+"""haiv: Seamless management of a collaborative AI team."""
+
+import io
+import os
+import shlex
+import sys
+import traceback
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from types import ModuleType
+from typing import cast
+
+import haiv_core
+import haiv_core.commands
+
+from haiv._infrastructure import env
+from haiv.paths import get_haiv_root, Paths
+from haiv._infrastructure.routing import find_route, RouteMatch
+from haiv._infrastructure.loader import load_command, load_commands_module
+from haiv._infrastructure.args import build_ctx
+from haiv._infrastructure.runner import run_command
+from haiv._infrastructure.identity import detect_user, Identity
+from haiv._infrastructure.resolvers import make_resolver
+from haiv._infrastructure.haiv_hooks import configure_haiv_hooks
+from haiv.util import module_to_folder
+
+__version__ = "0.1.0"
+
+# Core package root (computed once at import)
+_core_root = module_to_folder(haiv_core)
+
+# Cached haiv_root lookup
+_haiv_root: Path | None = None
+_haiv_root_error: Exception | None = None
+
+# Cached user detection
+_user: Identity | None = None
+_user_error: Exception | None = None
+
+
+def _get_haiv_root_cached() -> Path:
+    """Get haiv_root, caching the result (success or failure)."""
+    global _haiv_root, _haiv_root_error
+
+    if _haiv_root is None and _haiv_root_error is None:
+        try:
+            _haiv_root = get_haiv_root(cwd=Path.cwd())
+        except Exception as e:
+            _haiv_root_error = e
+
+    if _haiv_root_error is not None:
+        raise _haiv_root_error
+
+    return cast(Path, _haiv_root)
+
+
+def _detect_user_cached() -> Identity:
+    """Detect user, caching the result (success or failure)."""
+    global _user, _user_error
+
+    if _user is None and _user_error is None:
+        try:
+            haiv_root = _get_haiv_root_cached()
+            paths = Paths(_called_from=None, _pkg_root=None, _haiv_root=haiv_root, _core_root=_core_root)
+            _user = detect_user(paths.users_dir)
+            if _user is None:
+                raise Exception(
+                    "No user identity found.\n"
+                    "Run 'hv users new --name <name>' to create one."
+                )
+        except Exception as e:
+            _user_error = e
+
+    if _user_error is not None:
+        raise _user_error
+
+    return cast(Identity, _user)
+
+
+@dataclass
+class CommandSource:
+    """Tracks a command source and whether it was checked."""
+
+    name: str
+    path: str
+    checked: bool
+    error: str | None = None
+
+
+def _log_exception(exc: Exception) -> Path | None:
+    """Log exception to XDG_STATE_HOME/haiv/logs/. Returns log path or None on failure."""
+    from datetime import datetime
+
+    try:
+        state_home = os.environ.get("XDG_STATE_HOME", os.path.expanduser("~/.local/state"))
+        log_dir = Path(state_home) / "haiv" / "logs"
+        log_dir.mkdir(parents=True, exist_ok=True)
+
+        timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+        log_file = log_dir / f"error-{timestamp}.log"
+        with open(log_file, "w") as f:
+            f.write(traceback.format_exc())
+        return log_file
+    except Exception:
+        return None
+
+
+def _handle_error(exc: Exception) -> None:
+    """Handle an exception: print message, log traceback, exit."""
+    from haiv.errors import CommandError
+
+    log_path = _log_exception(exc)
+
+    if isinstance(exc, CommandError):
+        print(f"---\n{exc}", file=sys.stderr)
+    else:
+        print(f"---\nAn unexpected error occurred: {exc}", file=sys.stderr)
+
+    if log_path:
+        print(f"\n---\nDetails: {log_path}", file=sys.stderr)
+    else:
+        traceback.print_exc()
+
+    sys.exit(1)
+
+
+def _try_source(
+    command_string: str,
+    name: str,
+    path: str,
+    get_commands: Callable[[], ModuleType],
+) -> tuple[RouteMatch | None, CommandSource]:
+    """Try to find a command in a single source.
+
+    Args:
+        command_string: The command to find
+        name: Source name for error reporting
+        path: Source path for error reporting
+        get_commands: Callable that returns the commands module
+
+    Returns:
+        (route, source) - route is None if not found or source unavailable
+    """
+    try:
+        commands = get_commands()
+        route = find_route(command_string, commands)
+        return route, CommandSource(name, path, checked=True)
+    except Exception as e:
+        return None, CommandSource(name, path, checked=False, error=str(e))
+
+
+def _get_project_commands() -> ModuleType:
+    """Load haiv_project commands module."""
+    haiv_root = _get_haiv_root_cached()
+    os.environ[env.HV_ROOT] = str(haiv_root)
+
+    paths = Paths(_called_from=None, _pkg_root=None, _haiv_root=haiv_root, _core_root=_core_root)
+    return load_commands_module(paths.pkgs.project.commands_dir / "__init__.py")
+
+
+def _get_user_commands() -> ModuleType:
+    """Load haiv_user commands module."""
+    haiv_root = _get_haiv_root_cached()
+    user = _detect_user_cached()
+
+    paths = Paths(_called_from=None, _pkg_root=None, _haiv_root=haiv_root, _user_name=user.name, _core_root=_core_root)
+    return load_commands_module(paths.pkgs.user.commands_dir / "__init__.py")
+
+
+def _find_command(
+    command_string: str,
+) -> tuple[RouteMatch | None, Path | None, list[CommandSource]]:
+    """Try to find a command across all sources.
+
+    Returns:
+        (route, haiv_root, sources) - route is None if not found
+    """
+    sources: list[CommandSource] = []
+
+    # Try haiv_user first (highest precedence)
+    route, source = _try_source(
+        command_string,
+        "haiv_user",
+        "users/{user}/src/haiv_user/commands/",
+        _get_user_commands,
+    )
+    sources.append(source)
+    if route is not None:
+        return route, _haiv_root, sources
+
+    # Try haiv_project next
+    route, source = _try_source(
+        command_string,
+        "haiv_project",
+        "src/haiv_project/commands/",
+        _get_project_commands,
+    )
+    sources.append(source)
+    if route is not None:
+        return route, _haiv_root, sources
+
+    # Fall back to haiv_core (always available)
+    route, source = _try_source(
+        command_string,
+        "haiv_core",
+        "(installed)",
+        lambda: haiv_core.commands,
+    )
+    sources.append(source)
+
+    return route, _haiv_root, sources
+
+
+def _print_not_found(command_string: str, sources: list[CommandSource]) -> None:
+    """Print helpful error when command not found."""
+    print(f"Unknown command: {command_string}", file=sys.stderr)
+
+    checked = [s for s in sources if s.checked]
+    not_checked = [s for s in sources if not s.checked]
+
+    if checked:
+        print("\nChecked:", file=sys.stderr)
+        for s in checked:
+            print(f"  ✓ {s.name} {s.path}", file=sys.stderr)
+
+    if not_checked:
+        print("\nCould not check:", file=sys.stderr)
+        for s in not_checked:
+            print(f"  ✗ {s.name} {s.path}", file=sys.stderr)
+            if s.error:
+                print(f"    {s.error}", file=sys.stderr)
+
+
+def main():
+    """Entry point for haiv CLI.
+
+    Load order (later takes precedence over earlier):
+    1. Core package (haiv_core) - always available
+    2. Project package (haiv_project) - if in haiv-managed repo
+    3. User package (haiv_user) - deferred until user identity exists
+    """
+    cast(io.TextIOWrapper, sys.stdout).reconfigure(encoding="utf-8")
+    cast(io.TextIOWrapper, sys.stderr).reconfigure(encoding="utf-8")
+
+    # HV_PROG allows the wrapper script to pass its name (e.g., when using python -c)
+    prog = os.environ.get(env.HV_PROG) or Path(sys.argv[0]).name
+    args = sys.argv[1:]
+
+    if not args:
+        print(f"{prog} v{__version__}")
+        print(f"Usage: {prog} <command> [args...]")
+        print(f"Run '{prog} help' for available commands")
+        return
+
+    command_string = shlex.join(args)
+
+    route, haiv_root, sources = _find_command(command_string)
+
+    if route is None:
+        _print_not_found(command_string, sources)
+        sys.exit(1)
+        raise AssertionError("unreachable")
+
+    if route.file is None:
+        raise RuntimeError(
+            f"RouteMatch.file is None for '{command_string}'. "
+            "This indicates a bug in find_route() - it should return None "
+            "instead of a RouteMatch with file=None."
+        )
+
+    try:
+        command = load_command(route.file)
+        haiv_username = _user.name if _user else None
+
+        # Build resolver callback from discovered resolvers
+        # Order: haiv_core, haiv_project, haiv_user (later overrides earlier)
+        pkg_roots: list[Path] = []
+
+        # haiv_core
+        pkg_roots.append(_core_root)
+
+        # haiv_project and haiv_user via Paths
+        paths = None
+        if haiv_root is not None:
+            paths = Paths(
+                _called_from=None,
+                _pkg_root=None,
+                _haiv_root=haiv_root,
+                _user_name=haiv_username,
+                _core_root=_core_root,
+            )
+            if paths.pkgs.project.root.exists():
+                pkg_roots.append(paths.pkgs.project.root)
+            if haiv_username is not None and paths.pkgs.user.root.exists():
+                pkg_roots.append(paths.pkgs.user.root)
+
+        resolve = make_resolver(pkg_roots, paths=paths, has_user=haiv_username is not None)
+
+        definition = command.define()
+        haiv_hook_registry = None
+        if definition.enable_haiv_hooks:
+            haiv_hook_registry = configure_haiv_hooks(pkg_roots)
+
+        ctx = build_ctx(
+            route, command,
+            haiv_root=haiv_root,
+            haiv_username=haiv_username,
+            resolve=resolve,
+            haiv_hook_registry=haiv_hook_registry,
+        )
+        run_command(command, ctx)
+    except Exception as exc:
+        _handle_error(exc)
+
+
+if __name__ == "__main__":
+    main()

haiv_cli-0.1.0/tests/test_command_sources.py

@@ -0,0 +1,406 @@
+"""Integration tests for multi-source command loading."""
+
+import os
+import sys
+from pathlib import Path
+
+import pytest
+
+
+def _reset_cli_cache():
+    """Reset all cached lookups in haiv_cli."""
+    import haiv_cli
+    haiv_cli._haiv_root = None
+    haiv_cli._haiv_root_error = None
+    haiv_cli._user = None
+    haiv_cli._user_error = None
+
+
+@pytest.fixture
+def haiv_project(tmp_path, monkeypatch):
+    """Create a minimal haiv project structure."""
+    # Create haiv root markers
+    (tmp_path / ".git").mkdir()
+    (tmp_path / "worktrees").mkdir()
+
+    # Create haiv_project commands
+    commands_dir = tmp_path / "src" / "haiv_project" / "commands"
+    commands_dir.mkdir(parents=True)
+    (commands_dir / "__init__.py").write_text("# haiv_project commands")
+
+    # Create users directory (empty)
+    (tmp_path / "users").mkdir()
+
+    # Set HV_ROOT and change to project dir
+    monkeypatch.setenv("HV_ROOT", str(tmp_path))
+    monkeypatch.chdir(tmp_path)
+
+    _reset_cli_cache()
+
+    return tmp_path
+
+
+@pytest.fixture
+def haiv_project_with_user(haiv_project, monkeypatch):
+    """Create a haiv project with a user that matches current env."""
+    # Create user directory with identity.toml
+    user_dir = haiv_project / "users" / "testuser"
+    user_dir.mkdir(parents=True)
+
+    # Get current system user for matching
+    system_user = os.environ.get("USER", "nobody")
+    (user_dir / "identity.toml").write_text(f'''\
+[match]
+system_user = ["{system_user}"]
+''')
+
+    # Create haiv_user commands
+    commands_dir = user_dir / "src" / "haiv_user" / "commands"
+    commands_dir.mkdir(parents=True)
+    (commands_dir / "__init__.py").write_text("# haiv_user commands")
+
+    _reset_cli_cache()
+
+    return haiv_project
+
+
+class TestCommandSources:
+    """Tests for command source resolution."""
+
+    def test_core_command_works(self, monkeypatch):
+        """Commands from haiv_core are found."""
+        from haiv_cli import _find_command
+
+        _reset_cli_cache()
+
+        route, haiv_root, sources = _find_command("test_cmd")
+
+        assert route is not None
+        assert route.file is not None
+        assert route.file.name == "test_cmd.py"
+        # haiv_core should be in checked sources
+        core_sources = [s for s in sources if s.name == "haiv_core"]
+        assert len(core_sources) == 1
+        assert core_sources[0].checked is True
+
+    def test_project_command_takes_precedence(self, haiv_project):
+        """haiv_project commands override haiv_core commands."""
+        from haiv_cli import _find_command
+
+        # Create a test_cmd in haiv_project that shadows haiv_core's
+        commands_dir = haiv_project / "src" / "haiv_project" / "commands"
+        (commands_dir / "test_cmd.py").write_text('''
+from haiv import cmd
+
+def define() -> cmd.Def:
+    return cmd.Def(description="Project test command")
+
+def execute(ctx: cmd.Ctx) -> None:
+    print("Hello from haiv_project!")
+''')
+
+        route, haiv_root, sources = _find_command("test_cmd")
+
+        assert route is not None
+        # Should come from haiv_project, not haiv_core
+        assert "haiv_project" in str(route.file)
+        assert haiv_root == haiv_project
+
+    def test_project_only_command(self, haiv_project):
+        """Commands only in haiv_project are found."""
+        from haiv_cli import _find_command
+
+        # Create a command only in haiv_project
+        commands_dir = haiv_project / "src" / "haiv_project" / "commands"
+        (commands_dir / "project_only.py").write_text('''
+from haiv import cmd
+
+def define() -> cmd.Def:
+    return cmd.Def(description="Project-only command")
+
+def execute(ctx: cmd.Ctx) -> None:
+    print("Only in project!")
+''')
+
+        route, haiv_root, sources = _find_command("project_only")
+
+        assert route is not None
+        assert route.file is not None
+        assert route.file.name == "project_only.py"
+
+    def test_fallback_to_core_when_not_in_project(self, haiv_project):
+        """Falls back to haiv_core when command not in haiv_project."""
+        from haiv_cli import _find_command
+
+        # haiv_project exists but doesn't have test_cmd
+        route, haiv_root, sources = _find_command("test_cmd")
+
+        assert route is not None
+        assert "haiv_core" in str(route.file)
+
+    def test_reports_unchecked_sources(self, tmp_path, monkeypatch):
+        """Reports sources that couldn't be checked."""
+        from haiv_cli import _find_command
+
+        # Not in a haiv project
+        monkeypatch.chdir(tmp_path)
+        monkeypatch.delenv("HV_ROOT", raising=False)
+
+        _reset_cli_cache()
+
+        route, haiv_root, sources = _find_command("nonexistent")
+
+        assert route is None
+        # haiv_project should be unchecked
+        project_sources = [s for s in sources if s.name == "haiv_project"]
+        assert len(project_sources) == 1
+        assert project_sources[0].checked is False
+        assert project_sources[0].error is not None
+
+
+class TestUserCommandSources:
+    """Tests for user command source resolution."""
+
+    def test_user_command_takes_precedence_over_project(self, haiv_project_with_user):
+        """haiv_user commands override haiv_project commands."""
+        from haiv_cli import _find_command
+
+        # Create same command in both haiv_project and haiv_user
+        project_commands = haiv_project_with_user / "src" / "haiv_project" / "commands"
+        (project_commands / "shared_cmd.py").write_text('''
+from haiv import cmd
+
+def define() -> cmd.Def:
+    return cmd.Def(description="Project version")
+
+def execute(ctx: cmd.Ctx) -> None:
+    print("Hello from haiv_project!")
+''')
+
+        user_commands = haiv_project_with_user / "users" / "testuser" / "src" / "haiv_user" / "commands"
+        (user_commands / "shared_cmd.py").write_text('''
+from haiv import cmd
+
+def define() -> cmd.Def:
+    return cmd.Def(description="User version")
+
+def execute(ctx: cmd.Ctx) -> None:
+    print("Hello from haiv_user!")
+''')
+
+        route, haiv_root, sources = _find_command("shared_cmd")
+
+        assert route is not None
+        # Should come from haiv_user, not haiv_project
+        assert "haiv_user" in str(route.file)
+
+    def test_user_only_command(self, haiv_project_with_user):
+        """Commands only in haiv_user are found."""
+        from haiv_cli import _find_command
+
+        user_commands = haiv_project_with_user / "users" / "testuser" / "src" / "haiv_user" / "commands"
+        (user_commands / "user_only.py").write_text('''
+from haiv import cmd
+
+def define() -> cmd.Def:
+    return cmd.Def(description="User-only command")
+
+def execute(ctx: cmd.Ctx) -> None:
+    print("Only in user!")
+''')
+
+        route, haiv_root, sources = _find_command("user_only")
+
+        assert route is not None
+        assert route.file is not None
+        assert route.file.name == "user_only.py"
+
+    def test_fallback_to_project_when_not_in_user(self, haiv_project_with_user):
+        """Falls back to haiv_project when command not in haiv_user."""
+        from haiv_cli import _find_command
+
+        project_commands = haiv_project_with_user / "src" / "haiv_project" / "commands"
+        (project_commands / "project_cmd.py").write_text('''
+from haiv import cmd
+
+def define() -> cmd.Def:
+    return cmd.Def(description="Project command")
+
+def execute(ctx: cmd.Ctx) -> None:
+    print("From project!")
+''')
+
+        route, haiv_root, sources = _find_command("project_cmd")
+
+        assert route is not None
+        assert "haiv_project" in str(route.file)
+
+    def test_no_user_reports_unchecked(self, haiv_project):
+        """Reports haiv_user as unchecked when no user identity found."""
+        from haiv_cli import _find_command
+
+        # haiv_project exists but no user
+        route, haiv_root, sources = _find_command("test_cmd")
+
+        # haiv_user should be unchecked
+        user_sources = [s for s in sources if s.name == "haiv_user"]
+        assert len(user_sources) == 1
+        assert user_sources[0].checked is False
+        assert user_sources[0].error is not None
+        assert "No user identity found" in user_sources[0].error
+
+
+class TestResolverIntegration:
+    """Integration tests for resolver wiring in haiv_cli."""
+
+    def test_implicit_resolver_without_file_returns_raw_value(self, haiv_project_with_user):
+        """Implicit resolver (_name_/) without resolver file returns raw string."""
+        from haiv_cli import _find_command, main
+        from haiv._infrastructure.loader import load_command
+        from haiv._infrastructure.args import build_ctx
+        from haiv._infrastructure.resolvers import make_resolver
+
+        # Create command with implicit param resolver
+        commands_dir = haiv_project_with_user / "src" / "haiv_project" / "commands" / "_name_"
+        commands_dir.mkdir(parents=True)
+        (commands_dir.parent / "__init__.py").touch()
+        (commands_dir / "greet.py").write_text('''
+from haiv import cmd
+
+def define() -> cmd.Def:
+    return cmd.Def(description="Greet by name")
+
+def execute(ctx: cmd.Ctx) -> None:
+    name = ctx.args.get_one("name")
+    print(f"Hello, {name}!")
+''')
+
+        route, haiv_root, sources = _find_command("alice greet")
+
+        assert route is not None
+        assert route.params["name"].value == "alice"
+        assert route.params["name"].resolver == "name"
+
+        # Build resolve callback - no resolver file exists
+        pkg_roots = [haiv_project_with_user / "src" / "haiv_project"]
+        resolve = make_resolver(pkg_roots, None, has_user=True)
+
+        # Implicit resolver should return raw value
+        from haiv._infrastructure.args import ResolveRequest
+        req = ResolveRequest(param="name", resolver="name", value="alice")
+        result = resolve(req)
+
+        assert result == "alice"  # Raw value, no transformation
+
+    def test_explicit_resolver_without_file_raises_error(self, haiv_project_with_user):
+        """Explicit resolver (_target_as_mind_/) without file raises UnknownResolverError."""
+        from haiv_cli import _find_command
+        from haiv._infrastructure.resolvers import make_resolver, UnknownResolverError
+
+        # Create command with explicit param resolver
+        commands_dir = haiv_project_with_user / "src" / "haiv_project" / "commands" / "_target_as_mind_"
+        commands_dir.mkdir(parents=True)
+        (commands_dir.parent / "__init__.py").touch()
+        (commands_dir / "send.py").write_text('''
+from haiv import cmd
+
+def define() -> cmd.Def:
+    return cmd.Def(description="Send to mind")
+
+def execute(ctx: cmd.Ctx) -> None:
+    pass
+''')
+
+        route, haiv_root, sources = _find_command("forge send")
+
+        assert route is not None
+        assert route.params["target"].resolver == "mind"
+
+        # Build resolve callback - no resolver file exists
+        pkg_roots = [haiv_project_with_user / "src" / "haiv_project"]
+        resolve = make_resolver(pkg_roots, None, has_user=True)
+
+        # Explicit resolver should raise error
+        from haiv._infrastructure.args import ResolveRequest
+        req = ResolveRequest(param="target", resolver="mind", value="forge")
+
+        with pytest.raises(UnknownResolverError) as exc_info:
+            resolve(req)
+
+        assert exc_info.value.resolver_name == "mind"
+
+    def test_resolver_file_is_discovered_and_used(self, haiv_project_with_user):
+        """Resolver file in resolvers/ is discovered and used."""
+        from haiv._infrastructure.resolvers import make_resolver
+
+        # Create resolver file
+        resolvers_dir = haiv_project_with_user / "src" / "haiv_project" / "resolvers"
+        resolvers_dir.mkdir(parents=True)
+        (resolvers_dir / "mind.py").write_text('''
+def resolve(value, ctx):
+    return f"Mind({value})"
+''')
+
+        pkg_roots = [haiv_project_with_user / "src" / "haiv_project"]
+        resolve = make_resolver(pkg_roots, None, has_user=True)
+
+        from haiv._infrastructure.args import ResolveRequest
+        req = ResolveRequest(param="mind", resolver="mind", value="forge")
+        result = resolve(req)
+
+        assert result == "Mind(forge)"
+
+    def test_resolver_requires_user_when_found(self, haiv_project):
+        """Resolver raises UserRequiredError when has_user=False."""
+        from haiv._infrastructure.resolvers import make_resolver, UserRequiredError
+
+        # Create resolver file
+        resolvers_dir = haiv_project / "src" / "haiv_project" / "resolvers"
+        resolvers_dir.mkdir(parents=True)
+        (resolvers_dir / "mind.py").write_text('''
+def resolve(value, ctx):
+    return f"Mind({value})"
+''')
+
+        pkg_roots = [haiv_project / "src" / "haiv_project"]
+        resolve = make_resolver(pkg_roots, None, has_user=False)
+
+        from haiv._infrastructure.args import ResolveRequest
+        req = ResolveRequest(param="mind", resolver="mind", value="forge")
+
+        with pytest.raises(UserRequiredError) as exc_info:
+            resolve(req)
+
+        assert exc_info.value.resolver_name == "mind"
+
+    def test_user_resolver_overrides_project_resolver(self, haiv_project_with_user):
+        """User resolvers override project resolvers."""
+        from haiv._infrastructure.resolvers import make_resolver
+
+        # Create resolver in project
+        project_resolvers = haiv_project_with_user / "src" / "haiv_project" / "resolvers"
+        project_resolvers.mkdir(parents=True)
+        (project_resolvers / "mind.py").write_text('''
+def resolve(value, ctx):
+    return f"ProjectMind({value})"
+''')
+
+        # Create resolver in user (should win)
+        user_resolvers = haiv_project_with_user / "users" / "testuser" / "src" / "haiv_user" / "resolvers"
+        user_resolvers.mkdir(parents=True)
+        (user_resolvers / "mind.py").write_text('''
+def resolve(value, ctx):
+    return f"UserMind({value})"
+''')
+
+        pkg_roots = [
+            haiv_project_with_user / "src" / "haiv_project",
+            haiv_project_with_user / "users" / "testuser" / "src" / "haiv_user",
+        ]
+        resolve = make_resolver(pkg_roots, None, has_user=True)
+
+        from haiv._infrastructure.args import ResolveRequest
+        req = ResolveRequest(param="mind", resolver="mind", value="forge")
+        result = resolve(req)
+
+        assert result == "UserMind(forge)"  # User wins

haiv_cli-0.1.0/tests/test_imports.py

@@ -0,0 +1,34 @@
+"""Test that dependencies are correctly wired."""
+
+
+def test_can_import_haiv_core():
+    """Verify haiv-core is available as a dependency."""
+    from haiv_core import __version__
+
+    assert __version__ == "0.1.0"
+
+
+def test_can_import_haiv_transitively():
+    """Verify haiv is available transitively via haiv-core."""
+    from haiv import Container
+
+    assert Container is not None
+
+
+def test_can_import_haiv_cli():
+    """Verify haiv_cli itself imports."""
+    import haiv_cli
+
+    assert haiv_cli.__version__ == "0.1.0"
+
+
+def test_main_runs(monkeypatch):
+    """Verify main entry point runs without error."""
+    import sys
+    from haiv_cli import main
+
+    # Mock sys.argv to avoid picking up pytest args
+    monkeypatch.setattr(sys, "argv", ["hv"])
+
+    # Should not raise - prints usage and returns
+    main()