Skip to content

💫 Toolkit to help you get started with SDD or any other process!

49.3 KB
Raw Blame
"""Tests for VibeIntegration."""

import json
import os
from pathlib import Path
from unittest.mock import MagicMock, patch

import pytest
import yaml

from specify_cli.events import install_integration_events, remove_integration_events
from specify_cli.integrations import get_integration
from specify_cli.integrations.base import IntegrationBase, SkillsIntegration
from specify_cli.integrations.manifest import IntegrationManifest
from specify_cli.integrations.vibe import VibeIntegration

from .test_integration_base_skills import SkillsIntegrationTests

try:
    import tomllib
except ModuleNotFoundError:  # pragma: no cover - Python < 3.11
    import tomli as tomllib  # type: ignore


REPO_ROOT = Path(__file__).resolve().parents[2]


@pytest.fixture(autouse=True)
def _reset_vibe_model_invocation():
    """``setup()`` stores ``--no-model-invocation`` on the process-wide Vibe
    singleton; keep it from leaking between tests."""
    vibe = get_integration("vibe")
    vibe._disable_model_invocation = False
    yield
    vibe._disable_model_invocation = False


def _skill_frontmatter(skill_file: Path) -> dict:
    content = skill_file.read_text(encoding="utf-8")
    return yaml.safe_load(content.split("---", 2)[1])


def _vibe_manifest() -> MagicMock:
    manifest = MagicMock(spec=IntegrationManifest)
    manifest.files = {}
    manifest.record_file = MagicMock()
    manifest.record_existing = MagicMock()
    return manifest


class TestVibeIntegration(SkillsIntegrationTests):
    KEY = "vibe"
    FOLDER = ".vibe/"
    COMMANDS_SUBDIR = "skills"
    REGISTRAR_DIR = ".vibe/skills"

    def test_is_base_integration(self):
        assert isinstance(get_integration("vibe"), IntegrationBase)

    def test_multi_install_safe(self):
        integration = get_integration("vibe")
        assert integration.multi_install_safe is True

    def test_canonical_to_native_events(self):
        """Vibe supports exactly three hook types: pre_tool, post_tool, post_agent."""
        integration = get_integration("vibe")
        assert integration.CANONICAL_TO_NATIVE == {
            "pre_tool_use": "pre_tool",
            "post_tool_use": "post_tool",
            "stop": "post_agent",
        }

    def test_events_config(self):
        integration = get_integration("vibe")
        assert integration.events_config_file == ".vibe/hooks.toml"
        assert integration.events_format == "toml-vibe"

    def test_setup_creates_skill_files(self, tmp_path):
        integration = get_integration("vibe")
        manifest = IntegrationManifest("vibe", tmp_path)
        created = integration.setup(tmp_path, manifest, script_type="sh")

        skill_files = [path for path in created if path.name == "SKILL.md"]
        assert skill_files

        skills_dir = tmp_path / ".vibe" / "skills"
        assert skills_dir.is_dir()

        plan_skill = skills_dir / "speckit-plan" / "SKILL.md"
        assert plan_skill.exists()

        content = plan_skill.read_text(encoding="utf-8")
        assert "{SCRIPT}" not in content
        assert "{ARGS}" not in content
        assert "__AGENT__" not in content
        assert "__SPECKIT_COMMAND_" not in content, "unprocessed __SPECKIT_COMMAND_*__"
        assert "/speckit." not in content, "skills agent must use /speckit-<name> not /speckit.<name>"

        parts = content.split("---", 2)
        parsed = yaml.safe_load(parts[1])
        assert parsed["name"] == "speckit-plan"
        assert parsed["user-invocable"] is True
        assert parsed["disable-model-invocation"] is False
        assert parsed["metadata"]["source"] == "templates/commands/plan.md"

    def test_render_skill_unicode(self):
        """Test rendering a skill preserves non-ASCII characters."""
        integration = get_integration("vibe")
        rendered = integration._render_skill(
            "constitution",
            {"description": "Prüfe Konformität der Implementierung"},
            "Body",
        )
        assert "Prüfe Konformität" in rendered

    def test_setup_does_not_write_context_section(self, tmp_path):
        """The CLI no longer manages the agent context file — that is owned by
        the opt-in agent-context extension. Setup must not create or touch it."""
        integration = get_integration("vibe")
        manifest = IntegrationManifest("vibe", tmp_path)
        integration.setup(tmp_path, manifest, script_type="sh")

        for path in tmp_path.rglob("*"):
            if path.is_file():
                text = path.read_text(encoding="utf-8", errors="ignore")
                assert "<!-- SPECKIT START -->" not in text

    def test_teardown_does_not_touch_existing_context_file(self, tmp_path):
        """A user-authored context file is left intact on teardown."""
        integration = get_integration("vibe")
        ctx_path = tmp_path / "AGENTS.md"
        original = "# AGENTS.md\n\nUser content.\n"
        ctx_path.write_text(original, encoding="utf-8")

        manifest = IntegrationManifest("vibe", tmp_path)
        integration.setup(tmp_path, manifest, script_type="sh")
        integration.teardown(tmp_path, manifest)

        assert ctx_path.read_text(encoding="utf-8") == original

    def test_skills_do_not_have_argument_hint(self, tmp_path):
        """Vibe does not support argument-hint in skill frontmatter, so it must not be injected."""
        integration = get_integration("vibe")
        manifest = IntegrationManifest("vibe", tmp_path)
        created = integration.setup(tmp_path, manifest, script_type="sh")
        skill_files = [f for f in created if f.name == "SKILL.md"]
        assert skill_files
        for f in skill_files:
            content = f.read_text(encoding="utf-8")
            assert "argument-hint:" not in content, (
                f"{f.parent.name}/SKILL.md unexpectedly has argument-hint frontmatter"
            )

    def test_build_exec_args_uses_prompt_mode(self):
        integration = get_integration("vibe")

        args = integration.build_exec_args(
            "/speckit-specify build a login page",
            output_json=False,
        )

        assert args == ["vibe", "-p", "/speckit-specify build a login page"]

    def test_build_exec_args_requests_json_output(self):
        """Vibe's structured output is `--output json`; it has no `--output-format`."""
        integration = get_integration("vibe")

        args = integration.build_exec_args("/speckit-plan add OAuth", output_json=True)

        assert args == ["vibe", "-p", "/speckit-plan add OAuth", "--output", "json"]
        assert "--output-format" not in args

    def test_build_exec_args_omits_model_flag(self):
        """Vibe has no model flag; passing `--model` exits 2 at argument parsing."""
        integration = get_integration("vibe")

        args = integration.build_exec_args(
            "explain this repository",
            model="mistral-medium-latest",
            output_json=False,
        )

        assert args == ["vibe", "-p", "explain this repository"]
        assert "--model" not in args
        assert "mistral-medium-latest" not in args

    def test_build_exec_args_applies_extra_args(self, monkeypatch):
        monkeypatch.setenv("SPECKIT_INTEGRATION_VIBE_EXTRA_ARGS", "--auto-approve")
        integration = get_integration("vibe")

        args = integration.build_exec_args("check the build", output_json=True)

        assert args == [
            "vibe",
            "-p",
            "check the build",
            "--auto-approve",
            "--output",
            "json",
        ]


class TestVibeTomlMerging:
    """Behavioral tests for the toml-vibe hooks.toml generation and cleanup."""

    def _install(self, tmp_path, events):
        integration = get_integration("vibe")
        manifest = _vibe_manifest()
        install_integration_events(integration, tmp_path, manifest, events)
        return integration, manifest

    def _parse(self, tmp_path):
        return tomllib.loads((tmp_path / ".vibe" / "hooks.toml").read_text(encoding="utf-8"))

    def test_generated_toml_is_valid_and_schema_conformant(self, tmp_path):
        self._install(tmp_path, {
            "pre_tool_use": [{"command": "speckit.tdd.validate", "matcher": "Edit|Write"}],
            "stop": [{"command": "speckit.session.finish"}],
        })
        data = self._parse(tmp_path)
        hooks = data["hooks"]
        assert len(hooks) == 2
        by_type = {h["type"]: h for h in hooks}
        assert set(by_type) == {"pre_tool", "post_agent"}
        for h in hooks:
            assert h["name"].startswith("speckit-")
            assert isinstance(h["command"], str) and h["command"]
            assert isinstance(h["timeout"], int)
        # Canonical Claude-style regex matcher lands in Vibe's `match`
        # field with the `re:` escape — never in a `matcher` field.
        assert by_type["pre_tool"]["match"] == "re:Edit|Write"
        assert "matcher" not in by_type["pre_tool"]
        # HookConfig rejects `match` on post_agent hooks.
        assert "match" not in by_type["post_agent"]

    def test_wildcard_matcher_omitted(self, tmp_path):
        self._install(tmp_path, {
            "pre_tool_use": [{"command": "speckit.tdd.validate", "matcher": "*"}],
        })
        (hook,) = self._parse(tmp_path)["hooks"]
        assert "match" not in hook

    def test_non_bmp_matcher_round_trips_through_toml(self, tmp_path):
        """Vibe hook strings retain non-BMP Unicode rather than TOML-invalid surrogates."""
        matcher = "Edit|😀"
        self._install(tmp_path, {
            "pre_tool_use": [{"command": "speckit.tdd.validate", "matcher": matcher}],
        })
        (hook,) = self._parse(tmp_path)["hooks"]
        assert hook["match"] == f"re:{matcher}"

    @pytest.mark.parametrize("separator", ("\u0085", "\u2028", "\u2029"))
    def test_generated_matcher_unicode_separator_lifecycle(self, tmp_path, separator):
        """Unicode separators in TOML strings do not split managed hook spans."""
        matcher = f"Edit{separator}Write"
        integration, _ = self._install(tmp_path, {
            "pre_tool_use": [{"command": "speckit.tdd.validate", "matcher": matcher}],
        })
        assert self._parse(tmp_path)["hooks"][0]["match"] == f"re:{matcher}"

        self._install(tmp_path, {
            "pre_tool_use": [{"command": "speckit.review.verify", "matcher": matcher}],
        })
        (hook,) = self._parse(tmp_path)["hooks"]
        assert hook["name"] == "speckit-pre_tool-verify"
        assert hook["match"] == f"re:{matcher}"

        assert integration.remove_vibe_event_hooks(
            tmp_path, ensure_safe_destination=lambda _path: None
        ) is True
        assert not (tmp_path / ".vibe" / "hooks.toml").exists()

    def test_toml_quote_round_trips_special_characters(self):
        value = 'quote: " backslash: \\ newline: \n carriage: \r tab: \t nul: \x00 unit: \x1f del: \x7f'
        quoted = VibeIntegration._toml_quote(value)
        assert tomllib.loads(f"value = {quoted}\n")["value"] == value

    def test_unsupported_events_are_skipped(self, tmp_path, capsys):
        self._install(tmp_path, {
            "session_start": [{"command": "speckit.agent-context.update"}],
            "pre_tool_use": [{"command": "speckit.tdd.validate"}],
        })
        hooks = self._parse(tmp_path)["hooks"]
        assert [h["type"] for h in hooks] == ["pre_tool"]
        assert "does not support 'session_start'" in capsys.readouterr().err

    def test_multiple_handlers_get_unique_names(self, tmp_path):
        """Vibe drops duplicate hook names, so shared command stems must not collide."""
        self._install(tmp_path, {
            "pre_tool_use": [
                {"command": "speckit.tdd.validate"},
                {"command": "speckit.other.validate"},
            ],
        })
        hooks = self._parse(tmp_path)["hooks"]
        assert len(hooks) == 2
        names = [h["name"] for h in hooks]
        assert len(set(names)) == 2
        commands = " ".join(h["command"] for h in hooks)
        assert "speckit.tdd.validate" in commands
        assert "speckit.other.validate" in commands

    def test_reinstall_is_idempotent(self, tmp_path):
        events = {
            "pre_tool_use": [{"command": "speckit.tdd.validate", "matcher": "Bash"}],
            "stop": [{"command": "speckit.session.finish"}],
        }
        self._install(tmp_path, events)
        first = self._parse(tmp_path)["hooks"]
        self._install(tmp_path, events)
        second = self._parse(tmp_path)["hooks"]
        assert second == first

    def test_merge_and_teardown_preserve_user_hooks(self, tmp_path):
        config_path = tmp_path / ".vibe" / "hooks.toml"
        config_path.parent.mkdir(parents=True)
        user_block = (
            '[[hooks]]\n'
            'name = "deny-rm-rf"\n'
            'type = "pre_tool"\n'
            'match = "bash"\n'
            'command = "guard-bash"\n'
        )
        config_path.write_text(user_block, encoding="utf-8")

        integration, manifest = self._install(tmp_path, {
            "pre_tool_use": [{"command": "speckit.tdd.validate"}],
        })
        merged = self._parse(tmp_path)["hooks"]
        assert len(merged) == 2
        assert any(h["name"] == "deny-rm-rf" for h in merged)

        remove_integration_events(integration, tmp_path, manifest)
        remaining = self._parse(tmp_path)["hooks"]
        assert [h["name"] for h in remaining] == ["deny-rm-rf"]

    @pytest.mark.parametrize(
        "user_after",
        (
            "# NOTE: keep guard-bash first\n"
            "[[hooks]]\n"
            'name = "user-hook"\n'
            'type = "pre_tool"\n'
            'command = "guard-bash"\n',
            "# notes about these hooks\n",
        ),
        ids=("comment-before-user-hook", "trailing-comment"),
    )
    def test_refresh_and_teardown_keep_comments_after_a_managed_hook(
        self, tmp_path, user_after
    ):
        """A comment after a managed block is user content, not part of the block (#5079)."""
        path = tmp_path / ".vibe" / "hooks.toml"
        path.parent.mkdir(parents=True)
        path.write_bytes(
            b'[[hooks]]\nname = "deny-rm-rf"\ntype = "pre_tool"\ncommand = "guard-rm"\n'
        )
        events = {"pre_tool_use": [{"command": "speckit.tdd.validate"}]}
        integration, manifest = self._install(tmp_path, events)
        path.write_bytes(path.read_bytes() + ("\n" + user_after).encode("utf-8"))

        integration, manifest = self._install(tmp_path, events)
        assert user_after in path.read_text(encoding="utf-8")

        remove_integration_events(integration, tmp_path, manifest)
        remaining = path.read_text(encoding="utf-8")
        assert user_after in remaining
        assert "speckit_marker" not in remaining

    @pytest.mark.parametrize("newline", ("\n", "\r\n"), ids=("lf", "crlf"))
    def test_merge_preserves_user_physical_line_bytes(self, tmp_path, newline):
        """A native Windows write must not expand retained CRLF to CRCRLF."""
        user_content = (
            f"[[hooks]]{newline}"
            f'name = "user-hook"{newline}'
            f'type = "pre_tool"{newline}'
            f'command = "guard-bash"'
        )
        path = tmp_path / ".vibe" / "hooks.toml"
        path.parent.mkdir(parents=True)
        path.write_bytes((user_content + newline).encode("utf-8"))

        self._install(tmp_path, {"pre_tool_use": [{"command": "speckit.tdd.validate"}]})

        merged = path.read_bytes()
        assert merged.startswith(user_content.encode("utf-8") + b"\n\n")
        assert b"\r\r\n" not in merged
        assert [hook["name"] for hook in self._parse(tmp_path)["hooks"]] == [
            "user-hook",
            "speckit-pre_tool-validate",
        ]

    def test_merge_preserves_user_command_with_marker_text(self, tmp_path):
        """A marker-looking command string does not claim a user hook block."""
        config_path = tmp_path / ".vibe" / "hooks.toml"
        config_path.parent.mkdir(parents=True)
        user_block = (
            "[[hooks]]\n"
            'name = "user-hook"\n'
            'type = "pre_tool"\n'
            'command = "echo speckit_marker = true"\n'
        )
        config_path.write_text(user_block, encoding="utf-8")

        self._install(tmp_path, {"pre_tool_use": [{"command": "speckit.tdd.validate"}]})

        assert user_block in config_path.read_text(encoding="utf-8")
        assert [hook["name"] for hook in self._parse(tmp_path)["hooks"]] == [
            "user-hook",
            "speckit-pre_tool-validate",
        ]

    @pytest.mark.parametrize("separator", ("\u0085", "\u2028", "\u2029"))
    def test_comment_unicode_separator_cannot_spoof_marker(self, tmp_path, separator):
        """Only TOML LF and CRLF can end a comment for ownership scanning."""
        user_block = (
            "[[hooks]]\n"
            'name = "user-hook"\n'
            'type = "pre_tool"\n'
            f"# user note{separator}speckit_marker = true\n"
            'command = "guard-bash"\n'
        )
        path = tmp_path / ".vibe" / "hooks.toml"
        path.parent.mkdir(parents=True)
        original = user_block.encode()
        path.write_bytes(original)
        mtime_ns = 1_700_000_000_123_456_789
        os.utime(path, ns=(mtime_ns, mtime_ns))
        mtime_ns = path.stat().st_mtime_ns

        integration = get_integration("vibe")
        assert integration.remove_vibe_event_hooks(
            tmp_path, ensure_safe_destination=lambda _path: None
        ) is False
        assert path.read_bytes() == original
        assert path.stat().st_mtime_ns == mtime_ns

        self._install(tmp_path, {"pre_tool_use": [{"command": "speckit.tdd.validate"}]})
        assert user_block in path.read_bytes().decode("utf-8")
        assert [hook["name"] for hook in self._parse(tmp_path)["hooks"]] == [
            "user-hook",
            "speckit-pre_tool-validate",
        ]

    def test_commands_carry_structured_output_envelope(self, tmp_path):
        """Vibe parses non-empty hook stdout as JSON (HookStructuredResponse);
        plain text is reported as a hook failure. Every generated hook command
        must therefore pass the hook_specific_output envelope to the dispatcher."""
        self._install(tmp_path, {
            "pre_tool_use": [{"command": "speckit.tdd.validate"}],
            "stop": [{"command": "speckit.session.finish"}],
        })
        for hook in self._parse(tmp_path)["hooks"]:
            assert hook["command"].endswith(" hook_specific_output"), hook["name"]

    def test_windows_host_uses_cmd_quoting(self, tmp_path, monkeypatch):
        """Vibe runs hooks via create_subprocess_shell — cmd.exe on Windows,
        where POSIX single quotes don't quote. A host interpreter path with
        spaces must be double-quoted, never shlex-quoted."""
        import specify_cli.events as events_mod

        monkeypatch.setattr(
            VibeIntegration, "_hook_target_os", staticmethod(lambda: "cmd")
        )
        monkeypatch.setattr(
            events_mod, "_resolve_interpreter",
            lambda root: r"C:\Program Files\Python\python.exe",
        )
        self._install(tmp_path, {"pre_tool_use": [{"command": "speckit.tdd.validate"}]})
        (hook,) = self._parse(tmp_path)["hooks"]
        assert hook["command"].startswith('"C:\\Program Files\\Python\\python.exe" ')
        assert "'" not in hook["command"]

    def test_posix_host_keeps_shlex_quoting(self, tmp_path, monkeypatch):
        import specify_cli.events as events_mod

        # Pin the target: on a Windows CI runner _hook_target_os() would
        # return "cmd" and this test asserts the POSIX-host quoting path.
        monkeypatch.setattr(
            VibeIntegration, "_hook_target_os", staticmethod(lambda: "host")
        )
        monkeypatch.setattr(
            events_mod, "_resolve_interpreter",
            lambda root: "/opt/my venv/bin/python3",
        )
        self._install(tmp_path, {"pre_tool_use": [{"command": "speckit.tdd.validate"}]})
        (hook,) = self._parse(tmp_path)["hooks"]
        assert hook["command"].startswith("'/opt/my venv/bin/python3' ")

    def test_envelope_resolution(self):
        from specify_cli.events import _context_envelope_for
        integration = get_integration("vibe")
        for event in ("pre_tool_use", "post_tool_use", "stop"):
            assert _context_envelope_for(integration, event) == "hook_specific_output"

    def test_emit_wraps_stdout_as_structured_response(self, capsys):
        import json

        from specify_cli.events import _emit_event_stdout

        _emit_event_stdout("context line", "hook_specific_output")
        data = json.loads(capsys.readouterr().out)
        assert data == {
            "decision": "allow",
            "hook_specific_output": {"additional_context": "context line"},
        }

        # Empty stdout stays empty — Vibe treats it as "no response".
        _emit_event_stdout("", "hook_specific_output")
        assert capsys.readouterr().out == ""

    def test_teardown_deletes_file_without_user_content(self, tmp_path):
        integration, manifest = self._install(tmp_path, {
            "pre_tool_use": [{"command": "speckit.tdd.validate"}],
        })
        assert (tmp_path / ".vibe" / "hooks.toml").is_file()
        remove_integration_events(integration, tmp_path, manifest)
        assert not (tmp_path / ".vibe" / "hooks.toml").exists()

    def test_teardown_deletes_file_when_only_comments_remain(self, tmp_path):
        """A trailing comment survives refresh, but a file left with only
        comments is deleted, as for Codex's config.toml (#5079)."""
        path = tmp_path / ".vibe" / "hooks.toml"
        events = {"pre_tool_use": [{"command": "speckit.tdd.validate"}]}
        integration, manifest = self._install(tmp_path, events)
        path.write_bytes(path.read_bytes() + b"\n# notes about these hooks\n")

        integration, manifest = self._install(tmp_path, events)
        assert "# notes about these hooks" in path.read_text(encoding="utf-8")

        remove_integration_events(integration, tmp_path, manifest)
        assert not path.exists()


class TestVibeTomlNoOpRemoval:
    """Unowned Vibe hooks.toml files survive no-op cleanup byte-for-byte."""

    _FIXED_MTIME_NS = 1_700_000_000_123_456_789

    def _user_hooks_file(self, tmp_path, content):
        path = tmp_path / ".vibe" / "hooks.toml"
        path.parent.mkdir(parents=True)
        path.write_bytes(content)
        os.utime(path, ns=(self._FIXED_MTIME_NS, self._FIXED_MTIME_NS))
        return path, path.stat().st_mtime_ns

    def _assert_untouched(self, path, original, original_mtime_ns):
        assert path.exists()
        assert path.read_bytes() == original
        assert path.stat().st_mtime_ns == original_mtime_ns

    def test_empty_events_leave_user_crlf_file_untracked_and_untouched(self, tmp_path):
        integration = get_integration("vibe")
        manifest = _vibe_manifest()
        original = b'user_option = "keep"\r\nsecond_option = true'
        path, original_mtime_ns = self._user_hooks_file(tmp_path, original)

        install_integration_events(integration, tmp_path, manifest, {})

        self._assert_untouched(path, original, original_mtime_ns)
        manifest.record_existing.assert_not_called()

    def test_empty_events_preserve_comments_only_file(self, tmp_path):
        original = b"# maintained by the user\n# no hooks yet\n"
        path, original_mtime_ns = self._user_hooks_file(tmp_path, original)

        install_integration_events(get_integration("vibe"), tmp_path, _vibe_manifest(), {})

        self._assert_untouched(path, original, original_mtime_ns)

    def test_empty_events_preserve_whitespace_only_file(self, tmp_path):
        original = b"\r\n \t\r\n"
        path, original_mtime_ns = self._user_hooks_file(tmp_path, original)

        install_integration_events(get_integration("vibe"), tmp_path, _vibe_manifest(), {})

        self._assert_untouched(path, original, original_mtime_ns)

    def test_removal_preserves_user_comment_with_marker_text(self, tmp_path):
        integration = get_integration("vibe")
        original = (
            b"[[hooks]]\n"
            b'name = "user-hook"\n'
            b'type = "pre_tool"\n'
            b"# speckit_marker = true\n"
            b'command = "guard-bash"\n'
        )
        path, original_mtime_ns = self._user_hooks_file(tmp_path, original)

        removed_file = integration.remove_vibe_event_hooks(
            tmp_path, ensure_safe_destination=lambda _path: None
        )

        assert removed_file is False
        self._assert_untouched(path, original, original_mtime_ns)

    @pytest.mark.parametrize("newline", ("\n", "\r\n"), ids=("lf", "crlf"))
    def test_removal_recognizes_valid_marker_with_toml_line_endings(self, tmp_path, newline):
        """Removal uses both TOML line endings without expanding retained CRLF."""
        managed = (
            f"[[hooks]]{newline}"
            f"name = \"managed\"{newline}"
            f"speckit_marker = true{newline}"
        )
        user = (
            f"[[hooks]]{newline}"
            f"name = \"user-hook\"{newline}"
            f"command = \"guard-bash\"{newline}"
        )
        path, _ = self._user_hooks_file(tmp_path, (managed + user).encode())

        removed_file = get_integration("vibe").remove_vibe_event_hooks(
            tmp_path, ensure_safe_destination=lambda _path: None
        )

        assert removed_file is False
        assert path.read_bytes() == user.encode()

    @pytest.mark.parametrize(
        ("managed", "user"),
        (
            (
                '[[hooks]]\nname = "managed"\nspeckit_marker = true\n\n',
                "# NOTE: keep guard-bash first\n"
                "[[hooks]]\n"
                'name = "user-hook"\n'
                'command = "guard-bash"\n',
            ),
            # Blank lines after a kept comment stay with it.
            (
                '[[hooks]]\nname = "managed"\nspeckit_marker = true\n\n',
                '# NOTE: keep guard-bash first\n\n\n[[hooks]]\nname = "user-hook"\n',
            ),
            # A comment followed by more keys of the managed block is inside it.
            (
                '[[hooks]]\nname = "managed"\n# inside\n\nspeckit_marker = true\n\n',
                '[[hooks]]\nname = "user-hook"\n',
            ),
        ),
        ids=(
            "comment-before-user-hook",
            "blank-lines-after-comment",
            "comment-between-managed-keys",
        ),
    )
    @pytest.mark.parametrize("newline", ("\n", "\r\n"), ids=("lf", "crlf"))
    def test_removal_ends_a_managed_hook_at_its_last_toml_line(
        self, tmp_path, managed, user, newline
    ):
        """The blank separator goes with the managed block; a comment after it stays (#5079)."""
        managed = managed.replace("\n", newline)
        user = user.replace("\n", newline)
        path, _ = self._user_hooks_file(tmp_path, (managed + user).encode())

        removed_file = get_integration("vibe").remove_vibe_event_hooks(
            tmp_path, ensure_safe_destination=lambda _path: None
        )

        assert removed_file is False
        assert path.read_bytes() == user.encode()

    def test_removal_still_takes_comment_like_lines_inside_managed_values(self, tmp_path):
        """Lines inside a managed multiline string or array belong to its block."""
        managed = (
            "[[hooks]]\n"
            'name = "managed"\n'
            "speckit_marker = true\n"
            "args = [\n"
            "  # part of the array\n"
            '  "a",\n'
            "]\n"
            'command = """\n'
            "# part of the command\n"
            '"""\n'
        )
        user = '[[hooks]]\nname = "user-hook"\n'
        path, _ = self._user_hooks_file(tmp_path, (managed + user).encode())

        removed_file = get_integration("vibe").remove_vibe_event_hooks(
            tmp_path, ensure_safe_destination=lambda _path: None
        )

        assert removed_file is False
        assert path.read_bytes() == user.encode()

    def test_removal_preserves_marker_inside_multiline_strings(self, tmp_path):
        integration = get_integration("vibe")
        for name, delimiter in (("basic", '"""'), ("literal", "'''")):
            original = (
                "[[hooks]]\n"
                f"command = {delimiter}\n"
                "speckit_marker = true\n"
                f"{delimiter}\n"
            ).encode()
            path, original_mtime_ns = self._user_hooks_file(tmp_path / name, original)

            removed_file = integration.remove_vibe_event_hooks(
                tmp_path / name, ensure_safe_destination=lambda _path: None
            )

            assert removed_file is False
            self._assert_untouched(path, original, original_mtime_ns)

    def test_removal_accepts_spaced_hooks_header(self, tmp_path):
        integration = get_integration("vibe")
        path = tmp_path / ".vibe" / "hooks.toml"
        path.parent.mkdir(parents=True)
        path.write_text(
            "[[ hooks ]]\n"
            "speckit_marker = true\n"
            "[[hooks]]\n"
            'name = "user-hook"\n',
            encoding="utf-8",
        )

        removed_file = integration.remove_vibe_event_hooks(
            tmp_path, ensure_safe_destination=lambda _path: None
        )

        assert removed_file is False
        assert path.read_text(encoding="utf-8") == '[[hooks]]\nname = "user-hook"\n'

    def test_removal_does_not_cross_an_intervening_table(self, tmp_path):
        integration = get_integration("vibe")
        original = (
            b"[[hooks]]\n"
            b'command = "user-hook"\n'
            b"[other]\n"
            b"speckit_marker = true\n"
        )
        path, original_mtime_ns = self._user_hooks_file(tmp_path, original)

        removed_file = integration.remove_vibe_event_hooks(
            tmp_path, ensure_safe_destination=lambda _path: None
        )

        assert removed_file is False
        self._assert_untouched(path, original, original_mtime_ns)

    def test_removal_ignores_headers_inside_a_managed_multiline_string(self, tmp_path):
        integration = get_integration("vibe")
        path = tmp_path / ".vibe" / "hooks.toml"
        path.parent.mkdir(parents=True)
        path.write_text(
            "[[hooks]]\n"
            'command = """\n'
            "[[hooks]]\n"
            "not a header\n"
            '"""\n'
            "speckit_marker = true\n"
            "[other]\n"
            'value = "preserved"\n',
            encoding="utf-8",
        )

        removed_file = integration.remove_vibe_event_hooks(
            tmp_path, ensure_safe_destination=lambda _path: None
        )

        assert removed_file is False
        assert path.read_text(encoding="utf-8") == '[other]\nvalue = "preserved"\n'

    def test_removal_ignores_header_like_nested_arrays(self, tmp_path):
        """An array value must not split a managed array-of-tables block."""
        integration = get_integration("vibe")
        path = tmp_path / ".vibe" / "hooks.toml"
        path.parent.mkdir(parents=True)
        path.write_text(
            "[[hooks]]\n"
            "values = [\n"
            '  [[ "hooks" ]]\n'
            "]\n"
            "speckit_marker = true\n"
            "[other]\n"
            'value = "preserved"\n',
            encoding="utf-8",
        )
        assert tomllib.loads(path.read_text(encoding="utf-8"))["hooks"][0]["values"] == [
            [["hooks"]]
        ]

        removed_file = integration.remove_vibe_event_hooks(
            tmp_path, ensure_safe_destination=lambda _path: None
        )

        assert removed_file is False
        assert path.read_text(encoding="utf-8") == '[other]\nvalue = "preserved"\n'

    def test_removal_leaves_malformed_multiline_source_untouched(self, tmp_path):
        integration = get_integration("vibe")
        original = (
            b"[[hooks]]\n"
            b'command = """\n'
            b"speckit_marker = true\n"
        )
        path, original_mtime_ns = self._user_hooks_file(tmp_path, original)

        removed_file = integration.remove_vibe_event_hooks(
            tmp_path, ensure_safe_destination=lambda _path: None
        )

        assert removed_file is False
        self._assert_untouched(path, original, original_mtime_ns)

    @pytest.mark.parametrize(
        "original",
        [
            (
                "[[hooks]]\r\n"
                'name = "\u7528\u6237-hook"\r\n'
                "values = [speckit_marker = true]\r\n"
                "[other]\r\n"
                'keep = "\u4fdd\u7559"\r\n'
            ).encode(),
            (
                "[[hooks]]\n"
                'name = "caf\u00e9-user"\n'
                "bare invalid text\n"
                "speckit_marker = true\n"
                "[other]\n"
                'keep = "\u4fdd\u7559"\n'
            ).encode(),
            (
                "[[hooks]]\r"
                'name = "user-hook"\r'
                "speckit_marker = true\r"
            ).encode(),
        ],
        ids=("marker-like-array", "bare-invalid-text", "bare-cr"),
    )
    def test_malformed_toml_leaves_removal_and_merge_unowned_and_untouched(
        self, tmp_path, original
    ):
        """Invalid TOML must fail closed even when it resembles a managed hook."""
        integration = get_integration("vibe")
        with pytest.raises(tomllib.TOMLDecodeError):
            tomllib.loads(original.decode())
        path, original_mtime_ns = self._user_hooks_file(tmp_path, original)

        removed_file = integration.remove_vibe_event_hooks(
            tmp_path, ensure_safe_destination=lambda _path: None
        )

        assert removed_file is False
        self._assert_untouched(path, original, original_mtime_ns)

        manifest = _vibe_manifest()
        install_integration_events(
            integration,
            tmp_path,
            manifest,
            {"pre_tool_use": [{"command": "speckit.tdd.validate"}]},
        )

        self._assert_untouched(path, original, original_mtime_ns)
        manifest.record_existing.assert_not_called()

    def test_malformed_header_with_triple_quotes_leaves_removal_and_merge_untouched(
        self, tmp_path
    ):
        """Malformed header tokens must not let a user hook gain our marker."""
        integration = get_integration("vibe")
        original = (
            b"[[hooks]]\n"
            b'name = "user-owned"\n'
            b'[ """malformed-header""" ]\n'
            b"speckit_marker = true\n"
            b"[other]\n"
            b'keep = "survives"\n'
        )
        with pytest.raises(tomllib.TOMLDecodeError):
            tomllib.loads(original.decode("utf-8"))
        path, original_mtime_ns = self._user_hooks_file(tmp_path, original)

        removed_file = integration.remove_vibe_event_hooks(
            tmp_path, ensure_safe_destination=lambda _path: None
        )

        assert removed_file is False
        self._assert_untouched(path, original, original_mtime_ns)

        install_integration_events(
            integration,
            tmp_path,
            _vibe_manifest(),
            {"pre_tool_use": [{"command": "speckit.tdd.validate"}]},
        )

        self._assert_untouched(path, original, original_mtime_ns)

    def test_forced_teardown_preserves_unowned_file_with_manifest_claim(self, tmp_path):
        integration = get_integration("vibe")
        original = b'user_option = "keep"\r\n'
        path, original_mtime_ns = self._user_hooks_file(tmp_path, original)
        manifest = IntegrationManifest(integration.key, tmp_path, version="test")
        manifest.record_existing(".vibe/hooks.toml")
        manifest.save()

        integration.teardown(tmp_path, manifest, force=True)

        self._assert_untouched(path, original, original_mtime_ns)


class TestVibeUserInvocable:
    def test_all_skills_have_user_invocable(self, tmp_path):
        i = get_integration("vibe")
        m = IntegrationManifest("vibe", tmp_path)
        created = i.setup(tmp_path, m, script_type="sh")
        skill_files = [f for f in created if f.name == "SKILL.md"]
        assert skill_files
        for f in skill_files:
            content = f.read_text(encoding="utf-8")
            assert content.startswith("---"), (
                f"{f.parent.name}/SKILL.md is missing the opening frontmatter delimiter '---'"
            )
            parts = content.split("---", 2)
            assert len(parts) >= 3, (
                f"{f.parent.name}/SKILL.md has malformed frontmatter; expected a '--- ... ---' block"
            )
            parsed = yaml.safe_load(parts[1])
            assert parsed.get("user-invocable") is True, (
                f"{f.parent.name}/SKILL.md is missing user-invocable: true in frontmatter"
            )

    def test_all_skills_have_disable_model_invocation(self, tmp_path):
        i = get_integration("vibe")
        m = IntegrationManifest("vibe", tmp_path)
        created = i.setup(tmp_path, m, script_type="sh")
        skill_files = [f for f in created if f.name == "SKILL.md"]
        assert skill_files
        for f in skill_files:
            content = f.read_text(encoding="utf-8")
            parts = content.split("---", 2)
            parsed = yaml.safe_load(parts[1])
            assert parsed.get("disable-model-invocation") is False, (
                f"{f.parent.name}/SKILL.md is missing disable-model-invocation: false in frontmatter"
            )


class TestVibeInjectFrontmatterFlagNoTrailingNewline:
    """`_inject_frontmatter_flag` must not corrupt content whose closing
    frontmatter delimiter is the file's last line with no trailing newline.

    `post_process_skill_content` calls this helper on content from
    "external skill generators (presets, extensions)" (per the base
    class's docstring) -- not guaranteed to end with a trailing newline.
    Without a newline after the injected line, the injected text glues
    onto the closing `---`, destroying the delimiter.
    """

    def test_single_call_keeps_delimiter_on_its_own_line(self):
        from specify_cli.integrations.vibe import VibeIntegration

        content = "---\nname: x\n---"
        result = VibeIntegration._inject_frontmatter_flag(
            content, "user-invocable"
        )
        assert result == "---\nname: x\nuser-invocable: true\n---"

    def test_chained_calls_both_apply(self):
        """The exact sequence `post_process_skill_content` runs: a second
        injected key must still land, not be silently dropped because the
        first call already destroyed the closing `---` line."""
        from specify_cli.integrations.vibe import VibeIntegration

        content = "---\nname: x\n---"
        result = VibeIntegration._inject_frontmatter_flag(
            content, "user-invocable"
        )
        result = VibeIntegration._inject_frontmatter_flag(
            result, "disable-model-invocation", "false"
        )
        assert result == (
            "---\nname: x\nuser-invocable: true\n"
            "disable-model-invocation: false\n---"
        )

    def test_preserves_crlf_line_endings(self):
        """When the closing delimiter *does* end with \\r\\n, the injected
        line must reuse that EOL rather than switching the file to LF."""
        from specify_cli.integrations.vibe import VibeIntegration

        content = "---\r\nname: x\r\n---\r\n"
        result = VibeIntegration._inject_frontmatter_flag(
            content, "user-invocable"
        )
        assert result == "---\r\nname: x\r\nuser-invocable: true\r\n---\r\n"


class TestVibeNoModelInvocationOption:
    """``--integration-options="--no-model-invocation"`` opts out of model invocation (#2654)."""

    def test_options_include_no_model_invocation_flag(self):
        opts = get_integration("vibe").options()
        matching = [o for o in opts if o.name == "--no-model-invocation"]
        assert len(matching) == 1
        assert matching[0].is_flag is True
        # Opt-in: skills stay model-invocable unless the flag is passed.
        assert matching[0].default is False

    def test_setup_with_option_sets_disable_model_invocation_true(self, tmp_path):
        i = get_integration("vibe")
        m = IntegrationManifest("vibe", tmp_path)
        created = i.setup(
            tmp_path, m, parsed_options={"no_model_invocation": True}, script_type="sh"
        )
        skill_files = [f for f in created if f.name == "SKILL.md"]
        assert len(skill_files) > 0
        for f in skill_files:
            fm = _skill_frontmatter(f)
            assert fm["disable-model-invocation"] is True, f.parent.name
            assert fm["user-invocable"] is True, f.parent.name
            assert f.read_text(encoding="utf-8").count("disable-model-invocation:") == 1

    def test_post_process_follows_option_from_setup(self, tmp_path):
        """Preset overrides of core commands re-registered in the same run as
        ``setup()`` (init, upgrade) get the same value."""
        i = get_integration("vibe")
        i.setup(
            tmp_path,
            IntegrationManifest("vibe", tmp_path),
            parsed_options={"no_model_invocation": True},
            script_type="sh",
        )
        result = i.post_process_skill_content("---\nname: speckit-plan\n---\n\nBody\n")
        assert "disable-model-invocation: true" in result
        assert "disable-model-invocation: false" not in result

    def test_extension_skills_stay_model_invocable(self, tmp_path):
        """Mandatory extension hooks rely on the model invoking the hook skill,
        so the option never applies to extension commands."""
        i = get_integration("vibe")
        i.setup(
            tmp_path,
            IntegrationManifest("vibe", tmp_path),
            parsed_options={"no_model_invocation": True},
            script_type="sh",
        )
        result = i.post_process_skill_content(
            "---\nname: speckit-git-feature\n---\n\nBody\n"
        )
        assert "disable-model-invocation: false" in result
        assert "disable-model-invocation: true" not in result

    def test_option_requires_speckit_prefixed_core_name(self, tmp_path):
        """A skill merely named like a core stem is not a core command skill."""
        i = get_integration("vibe")
        i.setup(
            tmp_path,
            IntegrationManifest("vibe", tmp_path),
            parsed_options={"no_model_invocation": True},
            script_type="sh",
        )
        result = i.post_process_skill_content("---\nname: tasks\n---\n\nBody\n")
        assert "disable-model-invocation: false" in result
        result = i.post_process_skill_content("---\nname: speckit-tasks\n---\n\nBody\n")
        assert "disable-model-invocation: true" in result

    def test_failed_setup_does_not_leave_option_set(self, tmp_path):
        i = get_integration("vibe")
        with patch.object(SkillsIntegration, "setup", side_effect=RuntimeError("boom")):
            with pytest.raises(RuntimeError):
                i.setup(
                    tmp_path,
                    IntegrationManifest("vibe", tmp_path),
                    parsed_options={"no_model_invocation": True},
                    script_type="sh",
                )
        result = i.post_process_skill_content("---\nname: speckit-plan\n---\n\nBody\n")
        assert "disable-model-invocation: false" in result

    def test_setup_without_option_resets_to_false(self, tmp_path):
        i = get_integration("vibe")
        first = tmp_path / "first"
        first.mkdir()
        i.setup(
            first,
            IntegrationManifest("vibe", first),
            parsed_options={"no_model_invocation": True},
            script_type="sh",
        )
        second = tmp_path / "second"
        second.mkdir()
        created = i.setup(second, IntegrationManifest("vibe", second), script_type="sh")
        skill_files = [f for f in created if f.name == "SKILL.md"]
        assert len(skill_files) > 0
        for f in skill_files:
            assert _skill_frontmatter(f)["disable-model-invocation"] is False, f.parent.name
        result = i.post_process_skill_content("---\nname: speckit-plan\n---\n\nBody\n")
        assert "disable-model-invocation: false" in result

    def test_cli_rejects_value_for_flag(self, tmp_path):
        from typer.testing import CliRunner
        from specify_cli import app

        project = tmp_path / "vibe-bad-option"
        project.mkdir()
        old_cwd = os.getcwd()
        try:
            os.chdir(project)
            result = CliRunner().invoke(
                app,
                [
                    "init",
                    "--here",
                    "--integration",
                    "vibe",
                    "--integration-options",
                    "--no-model-invocation=yes",
                    "--script",
                    "sh",
                    "--ignore-agent-tools",
                ],
                catch_exceptions=False,
            )
        finally:
            os.chdir(old_cwd)

        assert result.exit_code != 0
        assert "does not accept a value" in result.output
        assert not (project / ".vibe" / "skills").exists()

    def test_option_persists_across_upgrade_and_can_be_cleared(self, tmp_path):
        from tests.specify_cli.integrations._helpers import _init_project, _run_in_project

        project = _init_project(tmp_path, "vibe", "--no-model-invocation")
        skills_dir = project / ".vibe" / "skills"
        skill_files = sorted(skills_dir.glob("*/SKILL.md"))
        assert len(skill_files) > 0
        for f in skill_files:
            assert _skill_frontmatter(f)["disable-model-invocation"] is True, f.parent.name

        state = json.loads((project / ".specify" / "integration.json").read_text(encoding="utf-8"))
        settings = state["integration_settings"]["vibe"]
        assert settings["raw_options"] == "--no-model-invocation"
        assert settings["parsed_options"] == {"no_model_invocation": True}

        # A later ``specify integration upgrade`` is a new process: drop the
        # in-memory value so only the persisted options can supply it.
        get_integration("vibe")._disable_model_invocation = False
        result = _run_in_project(project, ["integration", "upgrade", "vibe", "--force"])
        assert result.exit_code == 0, result.output
        for f in skill_files:
            assert _skill_frontmatter(f)["disable-model-invocation"] is True, f.parent.name

        # Passing replacement options (here: none) clears it.
        result = _run_in_project(
            project,
            ["integration", "upgrade", "vibe", "--force", "--integration-options", ""],
        )
        assert result.exit_code == 0, result.output
        for f in skill_files:
            assert _skill_frontmatter(f)["disable-model-invocation"] is False, f.parent.name
        state = json.loads((project / ".specify" / "integration.json").read_text(encoding="utf-8"))
        assert "parsed_options" not in state["integration_settings"]["vibe"]

    def test_upgrade_reapplies_option_to_preset_overrides(self, tmp_path):
        """``preset add`` runs without ``setup()`` (documented limitation);
        ``integration upgrade vibe --force`` reapplies the option to the
        core-command skills a preset overrides."""
        from tests.specify_cli.integrations._helpers import _init_project, _run_in_project

        project = _init_project(tmp_path, "vibe", "--no-model-invocation")
        skill_file = project / ".vibe" / "skills" / "speckit-plan" / "SKILL.md"
        assert _skill_frontmatter(skill_file)["disable-model-invocation"] is True

        get_integration("vibe")._disable_model_invocation = False
        result = _run_in_project(
            project, ["preset", "add", "--dev", str(REPO_ROOT / "presets" / "lean")]
        )
        assert result.exit_code == 0, result.output
        fm = _skill_frontmatter(skill_file)
        assert fm["metadata"]["source"] == "preset:lean"
        # Documented in docs/integrations/vibe.md; update the docs if
        # preset commands start honouring the option.
        assert fm["disable-model-invocation"] is False

        # The docs say ``--force`` is needed here: preset add modified
        # installed skill files, so a plain upgrade refuses.
        result = _run_in_project(project, ["integration", "upgrade", "vibe"])
        assert result.exit_code != 0
        assert "modified since installation" in result.output
        assert _skill_frontmatter(skill_file)["disable-model-invocation"] is False

        get_integration("vibe")._disable_model_invocation = False
        result = _run_in_project(project, ["integration", "upgrade", "vibe", "--force"])
        assert result.exit_code == 0, result.output
        fm = _skill_frontmatter(skill_file)
        assert fm["metadata"]["source"] == "preset:lean"
        assert fm["disable-model-invocation"] is True

    def test_extension_hook_skills_stay_model_invocable_after_upgrade(self, tmp_path):
        """``integration upgrade`` re-registers extension skills in the same
        process as ``setup()``; they must keep ``false`` so mandatory hooks
        (e.g. ``speckit.git.feature``) can still be invoked by the model."""
        from tests.specify_cli.integrations._helpers import _init_project, _run_in_project

        project = _init_project(tmp_path, "vibe", "--no-model-invocation")
        result = _run_in_project(
            project, ["extension", "add", "--dev", str(REPO_ROOT / "extensions" / "git")]
        )
        assert result.exit_code == 0, result.output
        get_integration("vibe")._disable_model_invocation = False
        result = _run_in_project(project, ["integration", "upgrade", "vibe", "--force"])
        assert result.exit_code == 0, result.output

        skills_dir = project / ".vibe" / "skills"
        git_skills = sorted(skills_dir.glob("speckit-git-*/SKILL.md"))
        assert git_skills, "git extension skills were not generated"
        for f in git_skills:
            assert _skill_frontmatter(f)["disable-model-invocation"] is False, f.parent.name
        assert _skill_frontmatter(skills_dir / "speckit-specify" / "SKILL.md")[
            "disable-model-invocation"
        ] is True