@rm0nroe/coach-claw 1.0.6

package/coach/tests/test_statusline_self_patch.py

@@ -0,0 +1,261 @@
+"""statusline_self_patch.ensure_statusline_installed — plugin self-patch
+of ~/.claude/settings.json:statusLine.
+
+Plugin distribution only. Gating happens at the call site
+(coach-session-start.py:_maybe_install_plugin_statusline checks
+CLAUDE_PLUGIN_ROOT). These tests exercise the patcher directly with a
+tmpdir settings.json.
+"""
+from __future__ import annotations
+
+import json
+import shlex
+from pathlib import Path
+
+import pytest
+
+import statusline_self_patch as sp
+
+
+@pytest.fixture
+def settings(tmp_path):
+    """Return a settings.json path inside tmp_path. Caller writes it."""
+    return tmp_path / "settings.json"
+
+
+@pytest.fixture
+def plugin_root(tmp_path):
+    root = tmp_path / "plugin"
+    (root / "bin").mkdir(parents=True)
+    return root
+
+
+def test_inserts_statusline_when_absent(settings, plugin_root):
+    settings.write_text(json.dumps({}))
+    result = sp.ensure_statusline_installed(str(plugin_root), settings_path=settings)
+    assert result == "installed"
+
+    written = json.loads(settings.read_text())
+    assert "statusLine" in written
+    cmd = written["statusLine"]["command"]
+    assert "bootstrap.sh" in cmd
+    assert "default_statusline.py" in cmd
+    # Absolute path (no ${CLAUDE_PLUGIN_ROOT} placeholder; that wouldn't
+    # expand inside settings.json).
+    assert "${CLAUDE_PLUGIN_ROOT}" not in cmd
+
+
+def test_preserves_other_keys(settings, plugin_root):
+    """Patching statusLine must not clobber unrelated settings."""
+    settings.write_text(json.dumps({
+        "permissions": {"allow": ["read"]},
+        "hooks": {"SessionStart": [{"hooks": [{"command": "foo"}]}]},
+    }))
+    sp.ensure_statusline_installed(str(plugin_root), settings_path=settings)
+    written = json.loads(settings.read_text())
+    assert written["permissions"] == {"allow": ["read"]}
+    assert "SessionStart" in written["hooks"]
+
+
+def test_noop_when_coach_statusline_already_present(settings, plugin_root):
+    """statusLine pointing at Coach's known marker → no-op (file
+    untouched)."""
+    settings.write_text(json.dumps({
+        "statusLine": {
+            "type": "command",
+            "command": "bash /some/other/path/default-statusline-command.sh",
+        },
+    }))
+    mtime_before = settings.stat().st_mtime_ns
+    result = sp.ensure_statusline_installed(str(plugin_root), settings_path=settings)
+    assert result == "matched"
+    assert settings.stat().st_mtime_ns == mtime_before, (
+        "matched path must not rewrite the file"
+    )
+
+
+def test_auto_wraps_when_other_statusline_present(
+    settings, plugin_root, tmp_path, monkeypatch
+):
+    """v0.1.4: claimed statusLine on first encounter → auto-wrap (instead
+    of leaving alone). Original is saved to .statusline-wrap.json and the
+    wrapper command replaces it in settings.json."""
+    coach_dir = tmp_path / "coach"
+    coach_dir.mkdir()
+    monkeypatch.setenv("COACH_CONFIG_DIR", str(coach_dir))
+
+    settings.write_text(json.dumps({
+        "statusLine": {"type": "command", "command": "bash /custom/user-thing.sh"},
+    }))
+    result = sp.ensure_statusline_installed(str(plugin_root), settings_path=settings)
+    assert result == "wrapped"
+    new_cmd = json.loads(settings.read_text())["statusLine"]["command"]
+    assert "statusline_wrap.py" in new_cmd
+    saved = json.loads((coach_dir / ".statusline-wrap.json").read_text())
+    assert saved["original_command"] == "bash /custom/user-thing.sh"
+
+
+def test_claimed_when_optout_marker_present(
+    settings, plugin_root, tmp_path, monkeypatch, capfd
+):
+    """User explicitly unwrapped earlier → opt-out marker exists → patcher
+    leaves the user's claimed statusLine alone (no auto-wrap, no rewrite)."""
+    coach_dir = tmp_path / "coach"
+    coach_dir.mkdir()
+    monkeypatch.setenv("COACH_CONFIG_DIR", str(coach_dir))
+    (coach_dir / ".statusline-wrap-disabled").write_text(json.dumps({
+        "reason": "user-unwrapped",
+    }))
+
+    settings.write_text(json.dumps({
+        "statusLine": {"type": "command", "command": "bash /custom/user-thing.sh"},
+    }))
+    result = sp.ensure_statusline_installed(str(plugin_root), settings_path=settings)
+    assert result == "claimed"
+    # User's command preserved
+    assert json.loads(settings.read_text())["statusLine"]["command"] == "bash /custom/user-thing.sh"
+
+
+def test_claimed_when_user_script_integrates_coach(
+    settings, plugin_root, tmp_path, monkeypatch
+):
+    """Manual-Coach pre-flight: user's script already calls coach/bin/stats.py
+    → patcher detects, writes opt-out marker, leaves statusLine alone."""
+    coach_dir = tmp_path / "coach"
+    coach_dir.mkdir()
+    monkeypatch.setenv("COACH_CONFIG_DIR", str(coach_dir))
+
+    user_script = tmp_path / "statusline-command.sh"
+    user_script.write_text(
+        "#!/bin/bash\nexec coach/bin/stats.py\n"
+    )
+    settings.write_text(json.dumps({
+        "statusLine": {"type": "command", "command": f"bash {user_script}"},
+    }))
+    result = sp.ensure_statusline_installed(str(plugin_root), settings_path=settings)
+    assert result == "claimed"
+    # Opt-out marker auto-written by manual-Coach pre-flight
+    disabled = json.loads((coach_dir / ".statusline-wrap-disabled").read_text())
+    assert disabled["reason"] == "already-integrated"
+
+
+def test_recognizes_wrapped_statusline_as_ours(settings, plugin_root):
+    """ours-wrapped pointing at the CURRENT plugin_root → matched no-op
+    (the wrap shape is recognized as ours, no rewrite)."""
+    settings.write_text(json.dumps({
+        "statusLine": {
+            "type": "command",
+            "command": f"{plugin_root}/bin/bootstrap.sh {plugin_root}/bin/statusline_wrap.py",
+        },
+    }))
+    result = sp.ensure_statusline_installed(str(plugin_root), settings_path=settings)
+    assert result == "matched"
+
+
+def test_refreshes_stale_plugin_path_on_wrapped(
+    settings, plugin_root, tmp_path, monkeypatch
+):
+    """ours-wrapped pointing at a stale plugin version dir → patcher
+    rewrites with the current plugin_root."""
+    coach_dir = tmp_path / "coach"
+    coach_dir.mkdir()
+    monkeypatch.setenv("COACH_CONFIG_DIR", str(coach_dir))
+    # Pretend an older plugin dir wrote the entry
+    old_root = tmp_path / "plugin-old"
+    settings.write_text(json.dumps({
+        "statusLine": {
+            "type": "command",
+            "command": f"{old_root}/bin/bootstrap.sh {old_root}/bin/statusline_wrap.py",
+        },
+    }))
+    # Also need a wrap marker so the action recognizes ours-wrapped
+    (coach_dir / ".statusline-wrap.json").write_text(json.dumps({
+        "original_command": "bash /opt/x.sh",
+    }))
+
+    result = sp.ensure_statusline_installed(str(plugin_root), settings_path=settings)
+    assert result == "wrap-refreshed"
+    new_cmd = json.loads(settings.read_text())["statusLine"]["command"]
+    assert str(plugin_root) in new_cmd
+    assert str(old_root) not in new_cmd
+
+
+def test_skipped_when_settings_absent(tmp_path, plugin_root):
+    """No settings.json → no-op (returns 'skipped'). Don't create it
+    from scratch — Claude Code itself will create it on first run."""
+    missing = tmp_path / "no-such-settings.json"
+    result = sp.ensure_statusline_installed(str(plugin_root), settings_path=missing)
+    assert result == "skipped"
+    assert not missing.exists()
+
+
+def test_error_on_malformed_json(settings, plugin_root):
+    """Existing settings.json that's not valid JSON → returns 'error',
+    never raises (caller is hook context — mustn't crash)."""
+    settings.write_text("{ not valid json")
+    result = sp.ensure_statusline_installed(str(plugin_root), settings_path=settings)
+    assert result == "error"
+
+
+def test_atomic_no_partial_write_on_failure(settings, plugin_root, monkeypatch):
+    """If json.dump raises mid-write, settings.json must not be
+    truncated. Verified by simulating an exception in os.replace."""
+    settings.write_text(json.dumps({"statusLine": None}))
+    original = json.loads(settings.read_text())
+
+    real_replace = sp.os.replace
+
+    def boom(*args, **kwargs):
+        raise OSError("simulated disk failure")
+
+    monkeypatch.setattr(sp.os, "replace", boom)
+    result = sp.ensure_statusline_installed(str(plugin_root), settings_path=settings)
+    assert result == "error"
+    # Original file content preserved (atomic semantics).
+    after = json.loads(settings.read_text())
+    assert after == original
+
+
+def test_recognizes_cli_installed_statusline(settings, plugin_root):
+    """A CLI-installed statusLine (uses default-statusline-command.sh)
+    must be recognized as 'ours' so the plugin doesn't try to
+    overwrite when the user has both installs side-by-side."""
+    settings.write_text(json.dumps({
+        "statusLine": {
+            "type": "command",
+            "command": "bash /Users/foo/.claude/coach/default-statusline-command.sh",
+        },
+    }))
+    result = sp.ensure_statusline_installed(str(plugin_root), settings_path=settings)
+    assert result == "matched"
+
+
+def test_recognizes_plugin_installed_statusline(settings, plugin_root):
+    """Plugin-installed statusLine (uses default_statusline.py via
+    bootstrap.sh) must also be recognized as 'ours' on the second
+    SessionStart."""
+    settings.write_text(json.dumps({
+        "statusLine": {
+            "type": "command",
+            "command": "/path/to/plugin/bin/bootstrap.sh /path/to/plugin/bin/default_statusline.py",
+        },
+    }))
+    result = sp.ensure_statusline_installed(str(plugin_root), settings_path=settings)
+    assert result == "matched"
+
+
+def test_desired_entry_quotes_paths_with_spaces(tmp_path):
+    """Symmetric with `_build_wrapper_command` in statusline_wrap_action:
+    a plugin_root with spaces must produce a command that bash parses
+    as exactly two tokens (bootstrap.sh + default_statusline.py)."""
+    plugin_root = tmp_path / "Plugin Dir With Spaces"
+    (plugin_root / "bin").mkdir(parents=True)
+    entry = sp._desired_entry(plugin_root)
+
+    tokens = shlex.split(entry["command"])
+    assert len(tokens) == 2, (
+        f"plugin_root paths split by bash; tokens={tokens!r} "
+        f"command={entry['command']!r}"
+    )
+    assert tokens[0] == str(plugin_root / "bin" / "bootstrap.sh")
+    assert tokens[1] == str(plugin_root / "bin" / "default_statusline.py")

package/coach/tests/test_statusline_variants.py

@@ -0,0 +1,110 @@
+"""statusline_variants.py — every variant renders for sample inputs and
+contains the expected key glyphs (level/name/elo/arrow)."""
+from __future__ import annotations
+
+import re
+
+import statusline_variants as sv
+
+
+def _strip_ansi(s: str) -> str:
+    return re.sub(r"\x1b\[[0-9;]*m", "", s)
+
+
+def _sample_glyphs(level: int = 7, session_xp: int = 15) -> sv.Glyphs:
+    return sv.Glyphs(
+        level=level,
+        name="Virtuoso",
+        elo=1232,
+        session_xp=session_xp,
+        sigil_tier="silver",
+        bar_pct=0.30,
+    )
+
+
+def test_every_variant_renders_a_non_empty_string():
+    g = _sample_glyphs()
+    for name in sv.VARIANTS:
+        assert sv.render(name, g), f"{name} produced empty output"
+
+
+def test_unknown_variant_falls_back_to_default():
+    g = _sample_glyphs()
+    fallback = sv.render("does-not-exist", g)
+    assert fallback == sv.render(sv.DEFAULT_VARIANT, g)
+
+
+def test_default_variant_is_crystal_and_includes_canonical_glyphs():
+    """Pin v0.2.0 visual contract — `◆ Ⅶ 1232 Virtuoso ↑15` shape."""
+    plain = _strip_ansi(sv.render("crystal", _sample_glyphs()))
+    assert plain == "◆ Ⅶ 1232 Virtuoso ↑15"
+
+
+def test_pips_variant_renders_pip_bar():
+    plain = _strip_ansi(sv.render("pips", _sample_glyphs()))
+    # bar_pct=0.30 → round(0.30*5) = 2 filled pips, 3 empty
+    assert plain.startswith("●●○○○ Virtuoso")
+    assert plain.endswith("↑15")
+
+
+def _glyphs_with_tier(tier: str) -> sv.Glyphs:
+    base = _sample_glyphs()
+    return sv.Glyphs(
+        level=base.level, name=base.name, elo=base.elo,
+        session_xp=base.session_xp, sigil_tier=tier, bar_pct=base.bar_pct,
+    )
+
+
+def test_pips_filled_glyph_color_tracks_sigil_tier():
+    """Filled `●` glyphs render in the sigil-tier color so the bar
+    progresses bronze → silver → gold → platinum → diamond as the user
+    levels up. Empty `○` glyphs stay DIM_STEEL."""
+    bronze_out = sv.render("pips", _glyphs_with_tier("bronze"))
+    diamond_out = sv.render("pips", _glyphs_with_tier("diamond"))
+    assert sv.SIGIL_COLORS["bronze"] in bronze_out
+    assert sv.SIGIL_COLORS["diamond"] in diamond_out
+    assert bronze_out != diamond_out
+
+
+def test_slash_variant_has_swords_sigil_and_drops_elo():
+    plain = _strip_ansi(sv.render("slash", _sample_glyphs()))
+    assert plain == "⚔ L7 / Virtuoso ↑15"
+
+
+def test_slash_sigil_color_tracks_sigil_tier():
+    """⚔ joins ◆ and ⚒ in the tier-color family — same mechanism."""
+    out = sv.render("slash", _glyphs_with_tier("diamond"))
+    assert sv.SIGIL_COLORS["diamond"] in out
+
+
+def test_forge_variant_uses_anvil_sigil():
+    plain = _strip_ansi(sv.render("forge", _sample_glyphs()))
+    assert plain == "⚒ Virtuoso · L7 ↑15"
+
+
+def test_bracket_variant_removed_from_registry():
+    """v0.1.4: bracket dropped. `render()` falls back to crystal so
+    saved configs with statusline_variant=bracket keep rendering."""
+    assert "bracket" not in sv.VARIANTS
+    assert len(sv.VARIANTS) == 4
+    fallback = sv.render("bracket", _sample_glyphs())
+    assert fallback == sv.render("crystal", _sample_glyphs())
+
+
+def test_zero_session_xp_drops_the_arrow():
+    g = _sample_glyphs(session_xp=0)
+    for name in sv.VARIANTS:
+        plain = _strip_ansi(sv.render(name, g))
+        assert "↑" not in plain, f"{name} kept the arrow at session_xp=0"
+
+
+def test_to_roman_handles_full_50_level_range():
+    expectations = {1: "Ⅰ", 4: "Ⅳ", 9: "Ⅸ", 10: "Ⅹ", 13: "ⅩⅢ", 50: "Ⅼ"}
+    for n, want in expectations.items():
+        assert sv.to_roman(n) == want, f"to_roman({n})"
+
+
+def test_list_variants_puts_default_first():
+    keys = sv.list_variants()
+    assert keys[0] == sv.DEFAULT_VARIANT
+    assert sorted(keys) == sorted(sv.VARIANTS.keys())

package/coach/tests/test_statusline_wrap.py

@@ -0,0 +1,196 @@
+"""statusline_wrap.py — runtime composer with ANSI-strip + trailing-aware
+separator detection. Failsafe contract: never crash the render."""
+from __future__ import annotations
+
+import json
+import sys
+import io
+from pathlib import Path
+
+import pytest
+
+import statusline_wrap as sw
+
+
+# --- compose() pure function ----------------------------------------------
+
+
+def test_compose_appends_when_original_ends_with_separator():
+    """User's command already trails with `┃` → just append, single space."""
+    out = sw.compose("opus·4.7 ┃ ▰▰▱▱ 14% ┃", "◆ Ⅷ 1265 Sensei ↑1")
+    assert out == "opus·4.7 ┃ ▰▰▱▱ 14% ┃ ◆ Ⅷ 1265 Sensei ↑1"
+
+
+def test_compose_strips_ansi_before_trailing_check():
+    """Real terminal output has ANSI color codes wrapped around the `┃`.
+    Last raw char is `m`; after ANSI-strip, last visible char is `┃`."""
+    ansi_pipe = "\x1b[38;2;30;144;255m┃\x1b[0m"
+    original = f"opus·4.7 \x1b[38;2;30;144;255m┃\x1b[0m ▰▰▱▱ 14% {ansi_pipe}"
+    out = sw.compose(original, "COACH")
+    # No double separator inserted — trailing `┃` was detected post-strip.
+    assert out.endswith(" COACH")
+    assert " ┃ COACH" not in out  # would be doubled
+
+
+def test_compose_uses_inline_separator_when_no_trailing_one():
+    """No trailing sep, but inline ` | ` runs around → insert one."""
+    out = sw.compose("a | b | c", "COACH")
+    assert out == "a | b | c | COACH"
+
+
+def test_compose_falls_through_to_space_when_no_separator_signal():
+    """Nothing recognizable → single-space join."""
+    out = sw.compose("plain text", "COACH")
+    assert out == "plain text COACH"
+
+
+def test_compose_empty_original_returns_coach_alone():
+    assert sw.compose("", "COACH") == "COACH"
+    assert sw.compose("   ", "COACH") == "COACH"
+
+
+def test_compose_empty_coach_returns_original_alone():
+    assert sw.compose("original ┃", "") == "original ┃"
+
+
+# --- inline-separator detection edge cases ---------------------------------
+
+
+def test_detect_inline_separator_picks_most_frequent():
+    assert sw._detect_inline_separator("a ┃ b ┃ c | d") == "┃"
+
+
+def test_detect_inline_separator_returns_none_when_squashed():
+    """`opus·4.7·(1m)` — `·` between alphanumerics, not space-padded.
+    Must not be picked as a separator."""
+    assert sw._detect_inline_separator("opus·4.7·(1m)") is None
+
+
+def test_detect_inline_separator_returns_none_on_no_separators():
+    assert sw._detect_inline_separator("plain text only") is None
+
+
+# --- runtime duplicate-detection signature --------------------------------
+
+
+def test_looks_like_coach_output_matches_sigil_plus_roman():
+    """`◆ Ⅷ` — sigil + roman within last 80 chars → duplicate signature."""
+    assert sw._looks_like_coach_output("model bar ┃ ◆ Ⅷ 1265 Sensei ↑1") is True
+
+
+def test_looks_like_coach_output_matches_sigil_plus_rank_name():
+    """`⚒ Virtuoso` — sigil + theme rank name → duplicate signature."""
+    assert sw._looks_like_coach_output("custom prefix ⚒ Virtuoso · L7 ↑15") is True
+
+
+def test_looks_like_coach_output_no_match_on_unrelated():
+    """No sigil → no match."""
+    assert sw._looks_like_coach_output("just plain text 14%") is False
+
+
+def test_looks_like_coach_output_no_match_on_sigil_alone():
+    """Sigil present but no roman + no rank → not a Coach signature."""
+    assert sw._looks_like_coach_output("symbol ◆ alone with no rank") is False
+
+
+def test_looks_like_coach_output_strips_ansi_first():
+    """ANSI colors around the sigil/numeral mustn't break detection."""
+    text = "x \x1b[38;2;200;205;215m◆\x1b[0m \x1b[1mⅧ\x1b[0m 1265"
+    assert sw._looks_like_coach_output(text) is True
+
+
+# --- main() integration with subprocess ------------------------------------
+
+
+@pytest.fixture
+def isolated_coach_dir(tmp_path, monkeypatch):
+    """Redirect resolve_coach_dir() to a tmp dir."""
+    monkeypatch.setenv("COACH_CONFIG_DIR", str(tmp_path))
+    return tmp_path
+
+
+def _write_marker(coach_dir: Path, command: str) -> None:
+    (coach_dir / sw.WRAP_MARKER_NAME).write_text(json.dumps({
+        "original_command": command,
+    }))
+
+
+def _run_main(monkeypatch, capsys, payload: str = ""):
+    monkeypatch.setattr("sys.stdin", io.StringIO(payload))
+    rc = sw.main()
+    return rc, capsys.readouterr().out
+
+
+def test_main_no_marker_emits_coach_alone(isolated_coach_dir, monkeypatch, capsys):
+    """Without a saved-original marker, the wrapper has nothing to run.
+    It still composes — original is empty, so just the coach segment
+    emits (or empty if no profile)."""
+    rc, out = _run_main(monkeypatch, capsys, payload="")
+    assert rc == 0
+    # Either empty (no profile signal) or starts with a sigil; both are
+    # valid failsafe outcomes. Key invariant: no traceback, no crash.
+    assert isinstance(out, str)
+
+
+def test_main_runs_saved_command_and_appends_coach(
+    isolated_coach_dir, monkeypatch, capsys, tmp_path
+):
+    """Saved original is `echo 'orig ┃'` → wrapper appends Coach with
+    trailing-aware logic (already has trailing ┃)."""
+    _write_marker(isolated_coach_dir, "printf 'orig ┃'")
+    monkeypatch.setattr(sw, "_coach_segment", lambda payload: "COACH")
+
+    rc, out = _run_main(monkeypatch, capsys, payload="")
+    assert rc == 0
+    assert out == "orig ┃ COACH"
+
+
+def test_main_timeout_emits_coach_alone(isolated_coach_dir, monkeypatch, capsys):
+    """Saved command sleeps past the 2s budget → original captured as ""
+    → wrapper falls through to coach-alone."""
+    _write_marker(isolated_coach_dir, "sleep 5")
+    monkeypatch.setattr(sw, "ORIGINAL_TIMEOUT_SECONDS", 0.1)
+    monkeypatch.setattr(sw, "_coach_segment", lambda payload: "COACH")
+
+    rc, out = _run_main(monkeypatch, capsys, payload="")
+    assert rc == 0
+    assert out == "COACH"
+
+
+def test_main_invalid_payload_does_not_crash(isolated_coach_dir, monkeypatch, capsys):
+    """Garbage stdin → parsed as empty dict; wrapper still emits."""
+    _write_marker(isolated_coach_dir, "printf 'orig'")
+    monkeypatch.setattr(sw, "_coach_segment", lambda payload: "COACH")
+
+    rc, out = _run_main(monkeypatch, capsys, payload="not json {{{")
+    assert rc == 0
+    assert "orig" in out
+
+
+def test_main_duplicate_detection_writes_marker_and_skips_coach(
+    isolated_coach_dir, monkeypatch, capsys
+):
+    """Original output already contains a Coach signature → the wrapper
+    must NOT append a second segment AND must drop a marker file for the
+    hook to surface the suggestion banner."""
+    _write_marker(isolated_coach_dir, "printf '◆ Ⅷ 1265 Sensei ↑1'")
+    monkeypatch.setattr(sw, "_coach_segment", lambda payload: "COACH")
+
+    rc, out = _run_main(monkeypatch, capsys, payload="")
+    assert rc == 0
+    assert "COACH" not in out
+    assert out == "◆ Ⅷ 1265 Sensei ↑1"
+    marker = isolated_coach_dir / sw.DUPLICATE_MARKER_NAME
+    assert marker.exists()
+
+
+def test_main_subprocess_failure_falls_back_to_coach(
+    isolated_coach_dir, monkeypatch, capsys
+):
+    """Saved command exits nonzero → original captured as "" → coach alone."""
+    _write_marker(isolated_coach_dir, "false")
+    monkeypatch.setattr(sw, "_coach_segment", lambda payload: "COACH")
+
+    rc, out = _run_main(monkeypatch, capsys, payload="")
+    assert rc == 0
+    assert out == "COACH"