@rm0nroe/coach-claw 1.0.6

package/coach/tests/test_hook_bespoke_dispatch.py

@@ -0,0 +1,288 @@
+"""coach-user-prompt.py: bespoke-theme dispatch in _assemble_celebrate_block.
+
+Pins the wiring between the hook's celebrate-block assembler and the
+banner_themes module. Specifically:
+
+  * craft theme + terminal: produces the historical default shape, byte-
+    identical to pre-feature output. No regression for the seven default
+    themes.
+  * bespoke theme + terminal: triggers banner_themes rendering.
+  * bespoke theme + ide: bypasses banner_themes (bespoke is terminal-only).
+  * banner_themes raises: hook falls through to default rendering — the
+    "hook crash never breaks a session" invariant.
+"""
+from __future__ import annotations
+
+import importlib.util
+from datetime import datetime, timezone
+from pathlib import Path
+
+import pytest
+
+import stats
+
+
+@pytest.fixture(autouse=True)
+def _hermetic_stats_globals(monkeypatch):
+    monkeypatch.setattr(stats, "LEVELS", stats._build_level_ladder())
+    monkeypatch.setattr(stats, "ELO_MIN", 1000)
+    monkeypatch.setattr(stats, "ELO_MAX", 2800)
+
+
+@pytest.fixture(scope="module")
+def cup():
+    """Load hooks/coach-user-prompt.py with bundle modules importable.
+
+    The hook's first action is `sys.path.insert(0, COACH_DIR/bin)` where
+    COACH_DIR points at the LIVE install (~/.claude/coach). That live
+    install may be stale relative to this checkout, so tests must not
+    trust whatever banner_themes happens to import during hook load.
+
+    We work around that here by:
+      1. Evicting any cached versions of the modules the hook will load.
+      2. Making bundle bin importable before executing the hook.
+      3. After exec, always evicting/re-importing banner_themes from the
+         bundle and patching the cup module so assertions pin source-tree
+         behavior, not installed-state behavior.
+
+    Production hook behavior is unchanged — this is purely for dev-time
+    test hermeticity."""
+    import sys
+    bundle_bin = str(Path(__file__).resolve().parents[2] / "coach" / "bin")
+
+    # Evict cached versions before loading.
+    for name in ("render_env", "banner_themes", "stats",
+                 "user_config", "themes"):
+        sys.modules.pop(name, None)
+
+    # Add bundle bin to sys.path (front). The hook's own insert at line
+    # 48 will bump this to position 1, but Python's import walks the
+    # whole list — bundle's banner_themes will be found there.
+    if bundle_bin not in sys.path:
+        sys.path.insert(0, bundle_bin)
+
+    repo_path = Path(__file__).resolve().parents[2] / "hooks" / "coach-user-prompt.py"
+    path = repo_path if repo_path.exists() else Path.home() / ".claude" / "hooks" / "coach-user-prompt.py"
+    if not path.exists():
+        pytest.skip(f"hook not installed at {path}")
+    spec = importlib.util.spec_from_file_location("cup_bespoke_dispatch", str(path))
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+
+    # ALWAYS force-load banner_themes from the bundle (not the live
+    # install). The hook's own `sys.path.insert(0, COACH_DIR/bin)` at
+    # line 48 puts the live install ahead of bundle, so without this
+    # evict-and-reimport step the test pins assertions against whatever
+    # banner_themes happens to be installed at ~/.claude/coach/bin/. We
+    # want tests to verify the BUNDLE's behavior — that's source of truth.
+    for name in ("render_env", "banner_themes"):
+        sys.modules.pop(name, None)
+    # Bundle bin must be ahead of live install for the re-import.
+    sys.path.insert(0, bundle_bin)
+    try:
+        from banner_themes import (  # noqa: E402
+            render_celebrate_for_theme,
+            BESPOKE_THEMES,
+        )
+        mod._render_celebrate_for_theme = render_celebrate_for_theme
+        mod._BESPOKE_THEMES = BESPOKE_THEMES
+        mod._BESPOKE_OK = True
+    except Exception as e:
+        pytest.skip(f"could not load banner_themes from bundle: {e}")
+    return mod
+
+
+NOW = datetime(2026, 5, 7, 17, 44, tzinfo=timezone.utc)
+YESTERDAY = datetime(2026, 5, 6, 19, 0, tzinfo=timezone.utc)
+
+
+def _streak_fixture():
+    return [
+        {"id": "safe-git-hygiene", "name": "safe git hygiene",
+         "streak": 4, "target": 5, "xp_awarded": 2, "direction": "positive"},
+        {"id": "heavy-subagent-delegation", "name": "heavy subagent delegation",
+         "streak": 4, "target": 5, "xp_awarded": 2, "direction": "negative"},
+    ]
+
+
+# -----------------------------------------------------------------------------
+# Default themes — craft / cosmic / marvel / dc / finalfantasy / lotr /
+# starwars MUST render the historical default shape. No bespoke dispatch.
+
+def test_craft_theme_terminal_renders_default_shape(cup):
+    """craft + terminal must produce the default `> ↑ name 🔴🔴🔴🔴⚪ ...`
+    shape — byte-for-byte regression guard for the seven untouched themes."""
+    block = cup._assemble_celebrate_block(
+        grads=[],
+        regs=[],
+        streak_rewards=_streak_fixture(),
+        levelup=None,
+        caught_up=False,
+        env="terminal",
+        theme="craft",
+        now=NOW,
+        streak_oldest=YESTERDAY,
+    )
+    assert block is not None
+    # Default streak rendering uses 🔴⚪ meter and inline backtick spans.
+    # If a regression flips this back to a bespoke shape, this test fails.
+    assert "> ↑ `safe git hygiene` `🔴🔴🔴🔴⚪` 4/5 · `+2`" in block
+    assert "> ↓ `heavy subagent delegation` `🔴🔴🔴🔴⚪` 4/5 · `-2`" in block
+    # Bespoke header / glyphs MUST NOT appear.
+    assert "Tide turned" not in block
+    assert "🦞" not in block
+    assert "≋" not in block
+
+
+def test_default_theme_with_caught_up_keeps_framing_line(cup):
+    """The catch-up framing line is part of the default shape and stays
+    in place for default themes — only bespoke themes drop it."""
+    block = cup._assemble_celebrate_block(
+        grads=[],
+        regs=[],
+        streak_rewards=_streak_fixture(),
+        levelup=None,
+        caught_up=True,
+        env="terminal",
+        theme="cosmic",
+        now=NOW,
+        streak_oldest=YESTERDAY,
+    )
+    assert block is not None
+    assert "Milestones earned across earlier sessions" in block
+
+
+# -----------------------------------------------------------------------------
+# Bespoke themes — terminal triggers banner_themes; IDE keeps default.
+
+def test_ocean_theme_terminal_uses_bespoke_render(cup):
+    block = cup._assemble_celebrate_block(
+        grads=[],
+        regs=[],
+        streak_rewards=_streak_fixture(),
+        levelup=None,
+        caught_up=True,
+        env="terminal",
+        theme="ocean",
+        now=NOW,
+        streak_oldest=YESTERDAY,
+    )
+    assert block is not None
+    assert "🦞  Tide turned · since yesterday" in block
+    assert "≋≋≋≋·  safe git hygiene" in block
+    # Catch-up framing line is REMOVED for bespoke themes — header carries
+    # the date instead.
+    assert "Milestones earned across earlier sessions" not in block
+
+
+def test_ocean_theme_ide_falls_back_to_default(cup):
+    """IDE rendering is terminal-only for bespoke themes. ocean + ide must
+    produce the default HR-framed shape, not bespoke ASCII frames."""
+    block = cup._assemble_celebrate_block(
+        grads=[],
+        regs=[],
+        streak_rewards=_streak_fixture(),
+        levelup=None,
+        caught_up=False,
+        env="ide",
+        theme="ocean",
+        now=NOW,
+        streak_oldest=YESTERDAY,
+    )
+    assert block is not None
+    # IDE shape uses HR frames; bespoke ocean header MUST NOT appear.
+    assert "Tide turned" not in block
+    assert "🦞  Tide turned" not in block
+    assert "≋≋≋≋·" not in block
+
+
+def test_hacker_theme_terminal_uses_bespoke_render(cup):
+    block = cup._assemble_celebrate_block(
+        grads=[],
+        regs=[],
+        streak_rewards=_streak_fixture(),
+        levelup={"to": "Hacker", "to_idx": 7, "xp_at_levelup": 90},
+        caught_up=False,
+        env="terminal",
+        theme="hacker",
+        now=NOW,
+        streak_oldest=YESTERDAY,
+    )
+    assert block is not None
+    assert "[coach@claw ~]$ tail -f session.log" in block
+    assert "safe_git_hygiene" in block
+    # Direction prefix on each row — RUN for positive, KILL for negative.
+    assert "RUN  safe_git_hygiene" in block
+    assert "KILL heavy_subagent_delegation" in block
+    # XP column uses [↑N xp] for both directions (gain in either case).
+    assert "[↑2 xp]" in block
+    assert "UPLINK ↑  L8 / Hacker 🥷" in block
+    assert "next breach 🔓 125 xp" in block
+
+
+def test_military_theme_terminal_uses_bespoke_render(cup):
+    block = cup._assemble_celebrate_block(
+        grads=[],
+        regs=[],
+        streak_rewards=_streak_fixture(),
+        levelup={"to": "Sensei", "to_idx": 7, "xp_at_levelup": 90},
+        caught_up=False,
+        env="terminal",
+        theme="military",
+        now=NOW,
+        streak_oldest=YESTERDAY,
+    )
+    assert block is not None
+    assert "SITREP" in block
+    assert "[PUSH] ▮▮▮▮▯  safe git hygiene" in block
+    assert "🎖️🎖️" in block  # 2 medals at L8
+    assert "Ⅷ" in block
+    assert "**Sensei**" in block
+
+
+# -----------------------------------------------------------------------------
+# Failure path — if banner_themes raises, the hook must fall back to
+# default rendering. Pins the "hook crash never breaks a session" invariant.
+
+def test_bespoke_render_failure_falls_back_to_default(cup, monkeypatch):
+    """Inject an exception into banner_themes.render_celebrate_for_theme
+    and verify the hook still produces a default-shape banner."""
+    def boom(*args, **kwargs):
+        raise RuntimeError("simulated bespoke crash")
+
+    monkeypatch.setattr(cup, "_render_celebrate_for_theme", boom)
+    block = cup._assemble_celebrate_block(
+        grads=[],
+        regs=[],
+        streak_rewards=_streak_fixture(),
+        levelup=None,
+        caught_up=False,
+        env="terminal",
+        theme="ocean",
+        now=NOW,
+        streak_oldest=YESTERDAY,
+    )
+    # Must produce a non-None banner (default shape) despite the crash.
+    assert block is not None
+    # Default shape markers — same as the craft regression test above.
+    assert "> ↑ `safe git hygiene`" in block
+    # No bespoke leakage.
+    assert "🦞" not in block
+    assert "≋" not in block
+
+
+def test_bespoke_dispatch_returns_none_when_nothing_to_render(cup):
+    """No streak rewards, no levelup, no grads/regs → None.
+    Mirrors the default path's empty-input behavior."""
+    block = cup._assemble_celebrate_block(
+        grads=[],
+        regs=[],
+        streak_rewards=[],
+        levelup=None,
+        caught_up=False,
+        env="terminal",
+        theme="ocean",
+        now=NOW,
+        streak_oldest=None,
+    )
+    assert block is None

package/coach/tests/test_hook_module_resolution.py

@@ -0,0 +1,116 @@
+"""Regression: hooks must use the bin/ that ships WITH them.
+
+Discovered during e2e validation (2026-05-09): the plugin's hooks were
+putting `~/.claude/coach/bin/` (the CLI's install dir) on sys.path
+instead of `${CLAUDE_PLUGIN_ROOT}/bin/`. When a user had the npm CLI
+installed at an older version that pre-dated newer plugin-track
+modules (cron_check, statusline_self_patch, etc.), the plugin's hook
+would silently fall back to the CLI's stale modules — and the imports
+inside `_maybe_install_plugin_statusline` and
+`_maybe_cron_nudge_block` would fail with `ModuleNotFoundError`,
+suppressed by the failsafe try/except.
+
+Net effect: the plugin's hook fired, but the new plugin-track
+behaviors silently no-op'd. statusLine never self-installed. Cron
+nudge never appeared. No error. No log line.
+
+Both hooks now branch on `CLAUDE_PLUGIN_ROOT`: if set, prefer the
+plugin's bin/; otherwise use the CLI's. This test pins that branch
+by importing each hook under controlled env vars and inspecting
+which path landed at `sys.path[0]`.
+"""
+from __future__ import annotations
+
+import importlib.util
+import sys
+from pathlib import Path
+
+import pytest
+
+REPO_ROOT = Path(__file__).resolve().parent.parent.parent
+SESSION_START_HOOK = REPO_ROOT / "hooks" / "coach-session-start.py"
+USER_PROMPT_HOOK = REPO_ROOT / "hooks" / "coach-user-prompt.py"
+
+
+def _import_isolated(path: Path, env_vars: dict[str, str], monkeypatch):
+    """Load a hook module with monkeypatched env vars + isolated sys.path.
+
+    Returns sys.path BEFORE the hook ran (saved snapshot) plus the
+    paths the hook prepended (everything new at the front of sys.path).
+    """
+    saved = list(sys.path)
+    # Drop any previous hook import cached in sys.modules so module-load
+    # side effects re-execute under the new env.
+    for mod_name in list(sys.modules):
+        if "cup_under_test" in mod_name or "css_under_test" in mod_name:
+            sys.modules.pop(mod_name)
+
+    for k in ("CLAUDE_PLUGIN_ROOT", "COACH_CONFIG_DIR"):
+        monkeypatch.delenv(k, raising=False)
+    for k, v in env_vars.items():
+        monkeypatch.setenv(k, v)
+
+    name = "css_under_test" if "session-start" in path.name else "cup_under_test"
+    spec = importlib.util.spec_from_file_location(name, str(path))
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+
+    # Anything in sys.path that wasn't there before are the prepends.
+    new_paths = [p for p in sys.path if p not in saved]
+    return new_paths, mod
+
+
+@pytest.fixture
+def fake_plugin(tmp_path):
+    """Two parallel bin dirs in tmp: a 'plugin' bin and a 'cli' bin.
+    Tests verify which one lands on sys.path."""
+    plugin_root = tmp_path / "plugin"
+    (plugin_root / "bin").mkdir(parents=True)
+    coach_dir = tmp_path / "coach"
+    (coach_dir / "bin").mkdir(parents=True)
+    return plugin_root, coach_dir
+
+
+@pytest.mark.parametrize("hook_path", [SESSION_START_HOOK, USER_PROMPT_HOOK])
+def test_plugin_context_uses_plugin_bin(hook_path, fake_plugin, monkeypatch):
+    plugin_root, coach_dir = fake_plugin
+    new_paths, _ = _import_isolated(
+        hook_path,
+        {
+            "CLAUDE_PLUGIN_ROOT": str(plugin_root),
+            "COACH_CONFIG_DIR": str(coach_dir),
+        },
+        monkeypatch,
+    )
+    plugin_bin = str(plugin_root / "bin")
+    cli_bin = str(coach_dir / "bin")
+    # plugin bin should be the FIRST insertion (sys.path[0])
+    assert new_paths and new_paths[0] == plugin_bin, (
+        f"With CLAUDE_PLUGIN_ROOT set, hook must put ${{CLAUDE_PLUGIN_ROOT}}/bin/ "
+        f"on sys.path. Expected first prepend = {plugin_bin!r}; got new paths = "
+        f"{new_paths!r}"
+    )
+    # CLI bin must NOT be on sys.path in plugin context — using stale CLI
+    # modules is the bug this test pins.
+    assert cli_bin not in sys.path, (
+        f"CLI bin {cli_bin!r} should NOT be on sys.path under plugin context. "
+        f"Got sys.path entries: {[p for p in sys.path if 'bin' in p]!r}"
+    )
+
+
+@pytest.mark.parametrize("hook_path", [SESSION_START_HOOK, USER_PROMPT_HOOK])
+def test_cli_context_uses_coach_bin(hook_path, fake_plugin, monkeypatch):
+    """Without CLAUDE_PLUGIN_ROOT, hooks fall back to ${COACH_DIR}/bin/
+    (the CLI install layout)."""
+    _, coach_dir = fake_plugin
+    new_paths, _ = _import_isolated(
+        hook_path,
+        {"COACH_CONFIG_DIR": str(coach_dir)},
+        monkeypatch,
+    )
+    cli_bin = str(coach_dir / "bin")
+    assert new_paths and new_paths[0] == cli_bin, (
+        f"Without CLAUDE_PLUGIN_ROOT, hook must put ${{COACH_CONFIG_DIR}}/bin/ "
+        f"on sys.path. Expected first prepend = {cli_bin!r}; got new paths = "
+        f"{new_paths!r}"
+    )