chore: import upstream snapshot with attribution

tests/test_cli/test_wrap_continue.py

@@ -0,0 +1,316 @@
+"""Tests for `headroom wrap continue` command (PR-G1, Phase G)."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+from click.testing import CliRunner
+
+from headroom.cli import wrap as wrap_mod
+from headroom.cli.main import main
+
+
+@pytest.fixture
+def runner() -> CliRunner:
+    return CliRunner()
+
+
+def test_inject_continue_rtk_systemmessage_new_file(tmp_path: Path) -> None:
+    """Writing into a non-existent config.json creates parents + sets systemMessage."""
+    config_file = tmp_path / ".continue" / "config.json"
+    assert not config_file.exists()
+
+    assert wrap_mod._inject_continue_rtk_systemmessage(config_file) is True
+
+    data = json.loads(config_file.read_text())
+    assert wrap_mod._RTK_MARKER in data["systemMessage"]
+
+
+def test_inject_continue_rtk_systemmessage_preserves_existing_keys(tmp_path: Path) -> None:
+    """Pre-existing keys are not touched; per-model entries get systemMessage."""
+    config_file = tmp_path / ".continue" / "config.json"
+    config_file.parent.mkdir(parents=True)
+    config_file.write_text(json.dumps({"models": [{"title": "GPT-4o", "provider": "openai"}]}))
+
+    wrap_mod._inject_continue_rtk_systemmessage(config_file)
+
+    data = json.loads(config_file.read_text())
+    # Pre-existing fields on the model entry are preserved verbatim.
+    assert data["models"][0]["title"] == "GPT-4o"
+    assert data["models"][0]["provider"] == "openai"
+    # Top-level systemMessage is set.
+    assert wrap_mod._RTK_MARKER in data["systemMessage"]
+    # Per-model systemMessage is also populated (Continue overrides top-level
+    # with per-model when set, so we must visit each model).
+    assert wrap_mod._RTK_MARKER in data["models"][0]["systemMessage"]
+
+
+def test_inject_continue_rtk_systemmessage_appends_to_existing_message(
+    tmp_path: Path,
+) -> None:
+    """Pre-existing systemMessage content is preserved; rtk block is appended."""
+    config_file = tmp_path / ".continue" / "config.json"
+    config_file.parent.mkdir(parents=True)
+    existing_msg = "You are a helpful assistant."
+    config_file.write_text(json.dumps({"systemMessage": existing_msg}))
+
+    wrap_mod._inject_continue_rtk_systemmessage(config_file)
+
+    data = json.loads(config_file.read_text())
+    assert data["systemMessage"].startswith(existing_msg)
+    assert wrap_mod._RTK_MARKER in data["systemMessage"]
+
+
+def test_inject_continue_rtk_systemmessage_idempotent(tmp_path: Path) -> None:
+    """Re-injection must not duplicate the marker."""
+    config_file = tmp_path / ".continue" / "config.json"
+
+    wrap_mod._inject_continue_rtk_systemmessage(config_file)
+    wrap_mod._inject_continue_rtk_systemmessage(config_file)
+
+    data = json.loads(config_file.read_text())
+    assert data["systemMessage"].count(wrap_mod._RTK_MARKER) == 1
+
+
+def test_inject_continue_rtk_systemmessage_refuses_invalid_json(
+    tmp_path: Path,
+) -> None:
+    """Malformed JSON must be left untouched and the helper must return False."""
+    config_file = tmp_path / ".continue" / "config.json"
+    config_file.parent.mkdir(parents=True)
+    malformed = '{ "models": [ this is not valid json'
+    config_file.write_text(malformed)
+
+    result = wrap_mod._inject_continue_rtk_systemmessage(config_file)
+
+    assert result is False
+    assert config_file.read_text() == malformed
+
+
+def test_inject_continue_rtk_systemmessage_refuses_non_object_root(
+    tmp_path: Path,
+) -> None:
+    """A JSON array at the root is not a valid Continue config; leave untouched."""
+    config_file = tmp_path / ".continue" / "config.json"
+    config_file.parent.mkdir(parents=True)
+    config_file.write_text("[]")
+
+    result = wrap_mod._inject_continue_rtk_systemmessage(config_file)
+
+    assert result is False
+    assert config_file.read_text() == "[]"
+
+
+def test_wrap_continue_prepare_only_injects_systemmessage(
+    runner: CliRunner,
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """`wrap continue --prepare-only` injects into ./.continue/config.json by default."""
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.delenv("HEADROOM_CONTEXT_TOOL", raising=False)
+
+    with patch.object(wrap_mod, "_ensure_rtk_binary", return_value=Path("/tmp/rtk")):
+        result = runner.invoke(main, ["wrap", "continue", "--prepare-only"])
+
+    assert result.exit_code == 0, result.output
+    config_file = tmp_path / ".continue" / "config.json"
+    assert config_file.exists()
+    data = json.loads(config_file.read_text())
+    assert wrap_mod._RTK_MARKER in data["systemMessage"]
+
+
+def test_wrap_continue_respects_custom_config_path(
+    runner: CliRunner,
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """--config writes to the user-specified path, not the cwd default."""
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.delenv("HEADROOM_CONTEXT_TOOL", raising=False)
+    custom_config = tmp_path / "custom" / "my-continue.json"
+
+    with patch.object(wrap_mod, "_ensure_rtk_binary", return_value=Path("/tmp/rtk")):
+        result = runner.invoke(
+            main,
+            ["wrap", "continue", "--prepare-only", "--config", str(custom_config)],
+        )
+
+    assert result.exit_code == 0, result.output
+    assert custom_config.exists()
+    assert not (tmp_path / ".continue" / "config.json").exists()
+    data = json.loads(custom_config.read_text())
+    assert wrap_mod._RTK_MARKER in data["systemMessage"]
+
+
+# ---------------------------------------------------------------------------
+# H1: non-string systemMessage must NOT be silently clobbered.
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "non_string_value",
+    [
+        {"role": "system", "content": "You are helpful."},  # dict
+        ["You are helpful.", "Respond in JSON."],  # list
+        42,  # int
+    ],
+    ids=["dict", "list", "int"],
+)
+def test_inject_continue_rtk_systemmessage_refuses_non_string_top_level(
+    tmp_path: Path,
+    non_string_value: object,
+) -> None:
+    """A non-string top-level systemMessage must NOT be overwritten."""
+    config_file = tmp_path / ".continue" / "config.json"
+    config_file.parent.mkdir(parents=True)
+    original_payload = {"systemMessage": non_string_value, "other": "untouched"}
+    config_file.write_text(json.dumps(original_payload))
+    original_bytes = config_file.read_bytes()
+
+    result = wrap_mod._inject_continue_rtk_systemmessage(config_file)
+
+    assert result is False, "must report refusal when user data would be clobbered"
+    # File must be byte-identical to before.
+    assert config_file.read_bytes() == original_bytes
+    data = json.loads(config_file.read_text())
+    assert data["systemMessage"] == non_string_value
+    assert data["other"] == "untouched"
+
+
+@pytest.mark.parametrize(
+    "non_string_value",
+    [
+        {"role": "system", "content": "Per-model system."},
+        ["List", "of", "strings"],
+        7,
+    ],
+    ids=["dict", "list", "int"],
+)
+def test_inject_continue_rtk_systemmessage_refuses_non_string_per_model(
+    tmp_path: Path,
+    non_string_value: object,
+) -> None:
+    """A non-string per-model systemMessage must NOT be overwritten."""
+    config_file = tmp_path / ".continue" / "config.json"
+    config_file.parent.mkdir(parents=True)
+    original_payload = {
+        "models": [
+            {"title": "GPT-4o", "provider": "openai", "systemMessage": non_string_value},
+        ],
+    }
+    config_file.write_text(json.dumps(original_payload))
+
+    result = wrap_mod._inject_continue_rtk_systemmessage(config_file)
+
+    assert result is False, "must report refusal when per-model user data would be clobbered"
+    data = json.loads(config_file.read_text())
+    # The non-string per-model value must be preserved.
+    assert data["models"][0]["systemMessage"] == non_string_value
+
+
+# ---------------------------------------------------------------------------
+# M2: per-model systemMessage handling.
+# ---------------------------------------------------------------------------
+
+
+def test_inject_continue_rtk_systemmessage_visits_each_model(
+    tmp_path: Path,
+) -> None:
+    """Each models[i].systemMessage gets the RTK block."""
+    config_file = tmp_path / ".continue" / "config.json"
+    config_file.parent.mkdir(parents=True)
+    config_file.write_text(
+        json.dumps(
+            {
+                "models": [
+                    {"title": "A", "systemMessage": "user value"},
+                    {"title": "B"},  # no systemMessage yet
+                ],
+            }
+        )
+    )
+
+    assert wrap_mod._inject_continue_rtk_systemmessage(config_file) is True
+
+    data = json.loads(config_file.read_text())
+    # Pre-existing per-model systemMessage is preserved + RTK block appended.
+    assert "user value" in data["models"][0]["systemMessage"]
+    assert wrap_mod._RTK_MARKER in data["models"][0]["systemMessage"]
+    # Model with no systemMessage gets the RTK block fresh.
+    assert wrap_mod._RTK_MARKER in data["models"][1]["systemMessage"]
+    # Top-level also populated.
+    assert wrap_mod._RTK_MARKER in data["systemMessage"]
+
+
+def test_inject_continue_rtk_systemmessage_per_model_idempotent(
+    tmp_path: Path,
+) -> None:
+    """Re-running must not duplicate per-model RTK blocks."""
+    config_file = tmp_path / ".continue" / "config.json"
+    config_file.parent.mkdir(parents=True)
+    config_file.write_text(
+        json.dumps({"models": [{"title": "A", "systemMessage": "user"}]}),
+    )
+
+    wrap_mod._inject_continue_rtk_systemmessage(config_file)
+    wrap_mod._inject_continue_rtk_systemmessage(config_file)
+
+    data = json.loads(config_file.read_text())
+    assert data["models"][0]["systemMessage"].count(wrap_mod._RTK_MARKER) == 1
+    assert data["systemMessage"].count(wrap_mod._RTK_MARKER) == 1
+
+
+def test_inject_continue_rtk_systemmessage_skips_non_dict_model_entries(
+    tmp_path: Path,
+) -> None:
+    """A models[] entry that isn't a dict must be left untouched."""
+    config_file = tmp_path / ".continue" / "config.json"
+    config_file.parent.mkdir(parents=True)
+    config_file.write_text(
+        json.dumps({"models": ["just a string entry", {"title": "B"}]}),
+    )
+
+    wrap_mod._inject_continue_rtk_systemmessage(config_file)
+
+    data = json.loads(config_file.read_text())
+    # Non-dict entry preserved verbatim.
+    assert data["models"][0] == "just a string entry"
+    # Dict entry got the RTK block.
+    assert wrap_mod._RTK_MARKER in data["models"][1]["systemMessage"]
+
+
+# ---------------------------------------------------------------------------
+# M4: Ctrl-C during prelude emits a clear message.
+# ---------------------------------------------------------------------------
+
+
+def test_wrap_continue_keyboardinterrupt_during_prelude_emits_clear_message(
+    runner: CliRunner,
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Ctrl-C between marker injection and proxy start must signal clearly."""
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.delenv("HEADROOM_CONTEXT_TOOL", raising=False)
+
+    config_file = tmp_path / ".continue" / "config.json"
+
+    def raise_kbd_after_inject(*args, **kwargs):  # noqa: ANN002, ANN003
+        # Simulate the user hitting Ctrl-C right after we wrote config.json
+        # but before the proxy started.
+        config_file.parent.mkdir(parents=True, exist_ok=True)
+        config_file.write_text('{"systemMessage": "marker block"}')
+        raise KeyboardInterrupt
+
+    with patch.object(wrap_mod, "_ensure_rtk_binary", side_effect=raise_kbd_after_inject):
+        result = runner.invoke(main, ["wrap", "continue", "--prepare-only"])
+
+    assert result.exit_code == 130
+    assert "interrupted" in result.output.lower()
+    assert "idempotent" in result.output.lower()
+    assert config_file.exists()
+    assert str(config_file) in result.output