@rm0nroe/coach-claw 1.0.6

package/coach/tests/test_render_env_glyphs.py

@@ -0,0 +1,119 @@
+"""render_env.supports_dual_blade — glyph-capability probe.
+
+Pins each branch of the detection order so a regression in one branch doesn't
+mask a regression in another. Each test passes an explicit `env` mapping to
+bypass the module-level cache (the cache is its own concern, tested separately
+below).
+"""
+from __future__ import annotations
+
+import pytest
+
+import render_env
+from render_env import supports_dual_blade
+
+
+@pytest.fixture(autouse=True)
+def _clear_dual_blade_cache():
+    """Module-level cache must not leak between tests."""
+    render_env._DUAL_BLADE_CACHE = None
+    yield
+    render_env._DUAL_BLADE_CACHE = None
+
+
+def test_default_modern_terminal_returns_true():
+    """Sensible default: a UTF-8 xterm with no overrides should render ⚔."""
+    env = {"LANG": "en_US.UTF-8", "TERM": "xterm-256color"}
+    assert supports_dual_blade(env) is True
+
+
+def test_force_ascii_kill_switch_wins():
+    """COACH_FORCE_ASCII_GLYPHS truthy beats every other signal."""
+    env = {
+        "COACH_FORCE_ASCII_GLYPHS": "1",
+        "COACH_SUPPORTS_DUAL_BLADE": "1",  # would otherwise be True
+        "LANG": "en_US.UTF-8",
+        "TERM": "xterm-256color",
+    }
+    assert supports_dual_blade(env) is False
+
+
+def test_explicit_support_override_true():
+    """COACH_SUPPORTS_DUAL_BLADE=1 forces True even if locale would say no."""
+    env = {"COACH_SUPPORTS_DUAL_BLADE": "true", "LANG": "C", "TERM": "dumb"}
+    assert supports_dual_blade(env) is True
+
+
+def test_explicit_support_override_false():
+    """COACH_SUPPORTS_DUAL_BLADE=0 forces False even on a UTF-8 xterm."""
+    env = {"COACH_SUPPORTS_DUAL_BLADE": "0", "LANG": "en_US.UTF-8",
+           "TERM": "xterm-256color"}
+    assert supports_dual_blade(env) is False
+
+
+def test_non_utf8_locale_returns_false():
+    """LANG=C with no UTF-8 anywhere → ASCII fallback."""
+    env = {"LANG": "C", "TERM": "xterm-256color"}
+    assert supports_dual_blade(env) is False
+
+
+def test_utf8_in_lc_all_alone_is_enough():
+    """Locale check accepts LC_ALL=UTF-8 when LANG is unset."""
+    env = {"LC_ALL": "en_US.UTF-8", "TERM": "xterm-256color"}
+    assert supports_dual_blade(env) is True
+
+
+def test_lc_all_overrides_lang_per_posix():
+    """POSIX precedence: LC_ALL wins over LANG. An explicit LC_ALL=C must
+    NOT be overridden by an otherwise-unused LANG=en_US.UTF-8."""
+    env = {"LC_ALL": "C", "LANG": "en_US.UTF-8", "TERM": "xterm-256color"}
+    assert supports_dual_blade(env) is False
+
+
+def test_lc_ctype_overrides_lang_when_lc_all_empty():
+    """When LC_ALL is unset, LC_CTYPE takes precedence over LANG."""
+    env = {"LC_CTYPE": "C", "LANG": "en_US.UTF-8", "TERM": "xterm-256color"}
+    assert supports_dual_blade(env) is False
+
+
+def test_lang_alone_is_consulted_when_others_empty():
+    """LANG is the lowest-priority fallback — used only when LC_ALL and
+    LC_CTYPE are both unset."""
+    env = {"LANG": "en_US.UTF-8", "TERM": "xterm-256color"}
+    assert supports_dual_blade(env) is True
+
+
+def test_term_dumb_returns_false():
+    """TERM=dumb is the canonical 'no fancy glyphs' signal."""
+    env = {"LANG": "en_US.UTF-8", "TERM": "dumb"}
+    assert supports_dual_blade(env) is False
+
+
+def test_term_linux_returns_false():
+    """Linux console framebuffer can't render U+2694."""
+    env = {"LANG": "en_US.UTF-8", "TERM": "linux"}
+    assert supports_dual_blade(env) is False
+
+
+def test_empty_env_defaults_true():
+    """No locale info at all → trust the default. Most cron / launchd
+    invocations on modern macOS/Linux work fine without LANG set."""
+    assert supports_dual_blade({}) is True
+
+
+def test_module_cache_returns_first_probe_result():
+    """First call (no env arg) populates the cache; subsequent calls
+    return the cached value without re-probing."""
+    render_env._DUAL_BLADE_CACHE = False
+    assert supports_dual_blade() is False  # served from cache
+    render_env._DUAL_BLADE_CACHE = True
+    assert supports_dual_blade() is True
+
+
+def test_explicit_env_does_not_pollute_cache():
+    """Tests pass an explicit env to force a probe; that probe must not
+    write back to the module cache (tests would interfere with each other
+    and with the normal hot-path read)."""
+    assert render_env._DUAL_BLADE_CACHE is None
+    supports_dual_blade({"LANG": "C", "TERM": "dumb"})
+    assert render_env._DUAL_BLADE_CACHE is None

package/coach/tests/test_reward_hints.py

@@ -0,0 +1,59 @@
+"""reward_hints.py — keyword inference + explicit-vs-inference precedence."""
+from __future__ import annotations
+
+from reward_hints import infer_reward_hint, effective_reward_hint
+
+
+def test_infer_test_run_from_id():
+    entry = {"id": "edits-without-testing", "nudge": ""}
+    hint = infer_reward_hint(entry)
+    assert hint is not None
+    assert hint["action"] == "test_run"
+    assert hint["xp"] == 2
+
+
+def test_infer_test_run_from_nudge_only():
+    entry = {"id": "some-unrelated-id", "nudge": "User skipped tests after edits."}
+    hint = infer_reward_hint(entry)
+    assert hint is not None
+    assert hint["action"] == "test_run"
+
+
+def test_infer_commit_from_id():
+    entry = {"id": "edits-without-committing", "nudge": ""}
+    hint = infer_reward_hint(entry)
+    assert hint is not None
+    assert hint["action"] == "commit"
+    assert hint["xp"] == 1
+
+
+def test_infer_no_match_returns_none():
+    entry = {"id": "random-pattern", "nudge": "Something with no keyword hit."}
+    assert infer_reward_hint(entry) is None
+
+
+def test_effective_explicit_wins_over_inference():
+    # id would match test_run via keyword, but explicit hint should dominate
+    entry = {
+        "id": "edits-without-testing",
+        "nudge": "",
+        "reward_hint": {"action": "commit", "xp": 1, "description": "explicit override"},
+    }
+    hint = effective_reward_hint(entry)
+    assert hint["action"] == "commit"
+    assert hint["description"] == "explicit override"
+
+
+def test_effective_falls_through_to_inference_when_invalid():
+    # reward_hint present but invalid (missing action) → fall through
+    entry = {"id": "edits-without-testing", "nudge": "", "reward_hint": {}}
+    hint = effective_reward_hint(entry)
+    assert hint["action"] == "test_run"
+
+
+def test_infer_returns_a_copy_not_default():
+    entry = {"id": "edits-without-testing", "nudge": ""}
+    h1 = infer_reward_hint(entry)
+    h1["xp"] = 99  # mutate caller's copy
+    h2 = infer_reward_hint(entry)
+    assert h2["xp"] == 2   # defaults unchanged

package/coach/tests/test_scoring.py

@@ -0,0 +1,147 @@
+"""scoring.py — baseline actions, SESSION_XP_CAP, dynamic reward_hint actions."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from scoring import (
+    BASELINE_ACTIONS,
+    SESSION_XP_CAP,
+    matches_action,
+    score_transcript,
+    score_transcript_with_breakdown,
+)
+
+
+def _write_transcript(path: Path, tool_uses: list[dict]) -> None:
+    """Write a minimal JSONL transcript with the given tool_uses."""
+    lines = []
+    for tu in tool_uses:
+        lines.append(json.dumps({"message": {"content": [dict(tu, type="tool_use")]}}))
+    path.write_text("\n".join(lines) + "\n")
+
+
+def test_baseline_test_run_scoring(tmp_path: Path):
+    t = tmp_path / "t.jsonl"
+    _write_transcript(t, [
+        {"name": "Bash", "input": {"command": "pytest tests/"}},
+        {"name": "Bash", "input": {"command": "pytest tests/unit/"}},
+    ])
+    assert score_transcript(t, {}) == 2 * BASELINE_ACTIONS["test_run"]
+
+
+def test_baseline_commit_scoring(tmp_path: Path):
+    t = tmp_path / "t.jsonl"
+    _write_transcript(t, [
+        {"name": "Bash", "input": {"command": "git commit -m 'x'"}},
+        {"name": "Bash", "input": {"command": "git commit -m 'y'"}},
+        {"name": "Bash", "input": {"command": "git commit -m 'z'"}},
+    ])
+    assert score_transcript(t, {}) == 3 * BASELINE_ACTIONS["commit"]
+
+
+def test_skill_invoke_counted_unique(tmp_path: Path):
+    t = tmp_path / "t.jsonl"
+    _write_transcript(t, [
+        {"name": "Skill", "input": {"skill": "/foo"}},
+        {"name": "Skill", "input": {"skill": "/foo"}},        # duplicate → same unique
+        {"name": "SlashCommand", "input": {"command": "/bar"}},
+    ])
+    # 2 unique skill ids (foo, bar) × 1 = 2
+    assert score_transcript(t, {}) == 2 * BASELINE_ACTIONS["skill_invoke"]
+
+
+def test_collect_only_pytest_ignored(tmp_path: Path):
+    t = tmp_path / "t.jsonl"
+    _write_transcript(t, [
+        {"name": "Bash", "input": {"command": "pytest --collect-only tests/"}},
+    ])
+    assert score_transcript(t, {}) == 0
+
+
+def test_shared_matcher_ignores_collect_only_pytest():
+    tu = {
+        "type": "tool_use",
+        "name": "Bash",
+        "input": {"command": "pytest --collect-only tests/"},
+    }
+    assert matches_action(tu, "test_run") is False
+
+
+@pytest.mark.parametrize("command", ["mocha", "yarn test", "pnpm test", "vitest"])
+def test_shared_matcher_accepts_supported_test_runners(command: str):
+    tu = {"type": "tool_use", "name": "Bash", "input": {"command": command}}
+    assert matches_action(tu, "test_run") is True
+
+
+def test_commit_message_text_does_not_count_as_action():
+    tu = {
+        "type": "tool_use",
+        "name": "Bash",
+        "input": {"command": "printf 'run pytest and git commit after this'"},
+    }
+    assert matches_action(tu, "test_run") is False
+    assert matches_action(tu, "commit") is False
+
+
+def test_session_cap_enforced(tmp_path: Path):
+    t = tmp_path / "t.jsonl"
+    # 20 test runs × 2 XP = 40 raw, capped at 15
+    _write_transcript(t, [
+        {"name": "Bash", "input": {"command": "pytest"}} for _ in range(20)
+    ])
+    assert score_transcript(t, {}) == SESSION_XP_CAP
+
+
+def test_dynamic_action_from_profile(tmp_path: Path):
+    t = tmp_path / "t.jsonl"
+    _write_transcript(t, [
+        {"name": "Edit", "input": {"file_path": "docs/README.md"}},
+        {"name": "Edit", "input": {"file_path": "docs/guide.md"}},
+        {"name": "Edit", "input": {"file_path": "src/main.py"}},  # not md → ignored
+    ])
+    profile = {
+        "entries": [{
+            "id": "skipping-docs",
+            "nudge": "",
+            "reward_hint": {"action": "doc_write", "xp": 1, "description": "doc update"},
+        }]
+    }
+    # 2 .md edits × 1 xp = 2
+    assert score_transcript(t, profile) == 2
+
+
+def test_breakdown_includes_dynamic_reward_hint_actions(tmp_path: Path):
+    t = tmp_path / "t.jsonl"
+    _write_transcript(t, [
+        {"name": "Bash", "input": {"command": "mocha"}},
+        {"name": "Edit", "input": {"file_path": "README.md"}},
+    ])
+    profile = {
+        "entries": [{
+            "id": "skipping-docs",
+            "reward_hint": {"action": "doc_write", "xp": 1, "description": "doc update"},
+        }]
+    }
+    got = score_transcript_with_breakdown(t, profile)
+    assert got["tests"] == 1
+    assert got["dynamic_actions"]["doc_write"] == {"count": 1, "xp_each": 1, "xp": 1}
+    assert got["available_dynamic_actions"] == {"doc_write": 1}
+    assert got["capped_xp"] == 3
+
+
+def test_baseline_action_not_double_counted_via_reward_hint(tmp_path: Path):
+    """reward_hint.action=test_run is BASELINE — must not double-count."""
+    t = tmp_path / "t.jsonl"
+    _write_transcript(t, [{"name": "Bash", "input": {"command": "pytest"}}])
+    profile = {
+        "entries": [{
+            "id": "edits-without-testing",
+            "nudge": "",
+            "reward_hint": {"action": "test_run", "xp": 2, "description": "test run"},
+        }]
+    }
+    # Should still be exactly +2 (baseline), not +4
+    assert score_transcript(t, profile) == 2

package/coach/tests/test_session_start_weekly_trigger.py

@@ -0,0 +1,92 @@
+"""Tests for the SessionStart hook's weekly insights trigger.
+
+Covers _maybe_spawn_weekly_insights — the 7-day-stale check that decides
+whether to fork insights-llm.sh on session start. The wrapper itself
+enforces the throttle inside its own logic; the hook just avoids the fork
+when we already know it would skip.
+"""
+from __future__ import annotations
+
+import importlib.util
+import os
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+import pytest
+
+HOOK_PATH = Path(__file__).resolve().parent.parent.parent / "hooks" / "coach-session-start.py"
+
+
+@pytest.fixture
+def hook_module(tmp_path, monkeypatch):
+    """Load the hook source against a tmp COACH_DIR.
+
+    The hook resolves COACH_DIR = Path.home() / ".claude" / "coach" at
+    module-load time, so we patch Path.home() to return tmp_path BEFORE
+    exec'ing the module, then create the matching dir tree under it.
+    """
+    coach_dir = tmp_path / ".claude" / "coach"
+    bin_dir = coach_dir / "bin"
+    bin_dir.mkdir(parents=True)
+
+    invocation_log = tmp_path / "invocation.log"
+    fake_script = bin_dir / "insights-llm.sh"
+    fake_script.write_text(
+        f"#!/bin/bash\necho fired > '{invocation_log}'\n"
+    )
+    fake_script.chmod(0o755)
+
+    monkeypatch.setattr("pathlib.Path.home", lambda: tmp_path)
+
+    spec = importlib.util.spec_from_file_location("coach_session_start", HOOK_PATH)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules["coach_session_start"] = module
+    spec.loader.exec_module(module)
+
+    return module, coach_dir, invocation_log
+
+
+def test_spawns_when_marker_missing(hook_module) -> None:
+    module, coach_dir, invocation_log = hook_module
+    assert not (coach_dir / ".last_weekly_insights").exists()
+    module._maybe_spawn_weekly_insights(datetime.now(timezone.utc))
+    # Wait briefly for the detached subprocess to finish writing.
+    for _ in range(20):
+        if invocation_log.exists():
+            break
+        time.sleep(0.1)
+    assert invocation_log.exists(), "expected wrapper to be spawned"
+
+
+def test_skips_when_marker_recent(hook_module) -> None:
+    module, coach_dir, invocation_log = hook_module
+    marker = coach_dir / ".last_weekly_insights"
+    marker.touch()
+    module._maybe_spawn_weekly_insights(datetime.now(timezone.utc))
+    # No fork should happen — wait, then assert nothing fired.
+    time.sleep(0.5)
+    assert not invocation_log.exists(), "wrapper was spawned despite recent marker"
+
+
+def test_spawns_when_marker_stale(hook_module) -> None:
+    module, coach_dir, invocation_log = hook_module
+    marker = coach_dir / ".last_weekly_insights"
+    marker.touch()
+    stale_ts = time.time() - 8 * 86400
+    os.utime(marker, (stale_ts, stale_ts))
+    module._maybe_spawn_weekly_insights(datetime.now(timezone.utc))
+    for _ in range(20):
+        if invocation_log.exists():
+            break
+        time.sleep(0.1)
+    assert invocation_log.exists(), "expected wrapper to fire on stale marker"
+
+
+def test_no_crash_when_script_missing(hook_module, tmp_path) -> None:
+    module, coach_dir, _ = hook_module
+    # Remove the script — the hook must still return cleanly.
+    (coach_dir / "bin" / "insights-llm.sh").unlink()
+    module._maybe_spawn_weekly_insights(datetime.now(timezone.utc))
+    # No exception is the assertion.