@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.c18009cd

package/integrations/hermes/tests/golden/memory_prefetch.txt

@@ -0,0 +1,5 @@
+## GSD memories
+- Auth uses JWT with refresh rotation
+
+## Hermes MEMORY.md (read-only)
+User prefers concise Slack updates.

package/integrations/hermes/tests/golden/snapshot.txt

@@ -0,0 +1,8 @@
+## GSD Project Snapshot
+Phase: execute
+Active milestone: M001: Hermes Integration
+Active slice: S01: Gateway MVP
+Active task: T01: Plugin scaffold
+Milestones: 0/1 done (1 active)
+Requirements: 2 active, 0 validated
+Next: Run contract tests for binding and snapshot golden.

package/integrations/hermes/tests/test_binding.py

@@ -0,0 +1,103 @@
+"""Tests for tiered binding resolver."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from open_gsd_hermes.binding import (
+    BindingError,
+    SessionBindStore,
+    resolve_explicit_project_dir,
+    resolve_project_dir,
+)
+from open_gsd_hermes.config import GsdConfig
+from open_gsd_hermes.types import BindingContext
+
+FIXTURE = Path(__file__).parent / "fixtures" / "minimal-project"
+
+
+@pytest.fixture
+def config() -> GsdConfig:
+    return GsdConfig(
+        default_project=None,
+        bindings={"slack": {"#eng-bot": str(FIXTURE)}},
+    )
+
+
+def test_slash_path_wins_over_channel_binding(
+    config: GsdConfig, tmp_path: Path
+) -> None:
+    other = tmp_path / "other"
+    other.mkdir()
+    (other / ".gsd").mkdir()
+    ctx = BindingContext(
+        slash_path=str(other),
+        platform="slack",
+        channel_id="#eng-bot",
+    )
+    assert resolve_project_dir(config, ctx) == str(other.resolve())
+
+
+def test_explicit_project_dir_rejects_invalid_project(tmp_path: Path) -> None:
+    with pytest.raises(BindingError):
+        resolve_explicit_project_dir(str(tmp_path / "missing"))
+
+
+def test_session_bind_wins_over_channel_binding(
+    config: GsdConfig, tmp_path: Path
+) -> None:
+    other = tmp_path / "other"
+    other.mkdir()
+    (other / ".gsd").mkdir()
+    store = SessionBindStore()
+    store.set("sess-1", str(other))
+    ctx = BindingContext(
+        session_bind=store.get("sess-1"),
+        platform="slack",
+        channel_id="#eng-bot",
+    )
+    assert resolve_project_dir(config, ctx) == str(other.resolve())
+
+
+def test_session_bind_wins_over_default(config: GsdConfig, tmp_path: Path) -> None:
+    other = tmp_path / "other"
+    other.mkdir()
+    (other / ".gsd").mkdir()
+    config.default_project = str(other)
+    store = SessionBindStore()
+    store.set("sess-1", str(FIXTURE))
+    ctx = BindingContext(session_bind=store.get("sess-1"))
+    assert resolve_project_dir(config, ctx) == str(FIXTURE.resolve())
+
+
+def test_channel_binding(config: GsdConfig) -> None:
+    ctx = BindingContext(platform="slack", channel_id="#eng-bot")
+    assert resolve_project_dir(config, ctx) == str(FIXTURE.resolve())
+
+
+def test_cron_explicit_over_channel(config: GsdConfig, tmp_path: Path) -> None:
+    cron_proj = tmp_path / "cron"
+    cron_proj.mkdir()
+    (cron_proj / ".gsd").mkdir()
+    ctx = BindingContext(
+        cron_project=str(cron_proj),
+        platform="slack",
+        channel_id="#eng-bot",
+    )
+    assert resolve_project_dir(config, ctx) == str(cron_proj.resolve())
+
+
+def test_fail_closed(config: GsdConfig) -> None:
+    with pytest.raises(BindingError):
+        resolve_project_dir(config, BindingContext())
+
+
+def test_fail_open_returns_none(config: GsdConfig) -> None:
+    assert resolve_project_dir(config, BindingContext(), fail_closed=False) is None
+
+
+def test_cwd_heuristic(config: GsdConfig) -> None:
+    ctx = BindingContext(cwd=str(FIXTURE))
+    assert resolve_project_dir(config, ctx) == str(FIXTURE.resolve())

package/integrations/hermes/tests/test_config.py

@@ -0,0 +1,42 @@
+"""Tests for Hermes plugin configuration defaults."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from open_gsd_hermes.config import GsdConfig, config_path
+
+
+def test_default_gsd_version_range_matches_plugin_release_train() -> None:
+    config = GsdConfig()
+
+    assert config.gsd_version_min == "2.53"
+    assert config.gsd_version_max == "3.0"
+
+
+def test_dict_fallback_gsd_version_range_matches_plugin_release_train() -> None:
+    config = GsdConfig.from_dict({"gsd": {}})
+
+    assert config.gsd_version_min == "2.53"
+    assert config.gsd_version_max == "3.0"
+
+
+def test_mcp_read_timeout_can_be_configured() -> None:
+    config = GsdConfig.from_dict({"gsd": {"mcp_read_timeout_seconds": 12.5}})
+
+    assert config.mcp_read_timeout_seconds == 12.5
+
+
+def test_config_path_respects_hermes_home(tmp_path: Path, monkeypatch) -> None:
+    monkeypatch.delenv("HERMES_GSD_CONFIG", raising=False)
+    monkeypatch.setenv("HERMES_HOME", str(tmp_path / "hermes-home"))
+
+    assert config_path() == tmp_path / "hermes-home" / "gsd.yaml"
+
+
+def test_config_path_explicit_env_wins(tmp_path: Path, monkeypatch) -> None:
+    explicit = tmp_path / "custom-gsd.yaml"
+    monkeypatch.setenv("HERMES_HOME", str(tmp_path / "hermes-home"))
+    monkeypatch.setenv("HERMES_GSD_CONFIG", str(explicit))
+
+    assert config_path() == explicit

package/integrations/hermes/tests/test_cron.py

@@ -0,0 +1,34 @@
+"""Cron CLI tests."""
+
+from __future__ import annotations
+
+from open_gsd_hermes import cron
+from open_gsd_hermes.config import GsdConfig
+
+
+def test_main_prefers_cli_project_over_gsd_cron_project(monkeypatch, tmp_path) -> None:
+    cli_project = tmp_path / "cli-project"
+    env_project = tmp_path / "env-project"
+    captured: dict[str, object] = {}
+
+    monkeypatch.setenv("GSD_CRON_PROJECT", str(env_project))
+    monkeypatch.setattr(cron, "load_config", lambda: GsdConfig())
+
+    def fake_run_headless_auto(
+        project_dir: str,
+        config: GsdConfig,
+        *,
+        timeout_seconds: int,
+    ) -> cron.CronResult:
+        captured["project_dir"] = project_dir
+        captured["config"] = config
+        captured["timeout_seconds"] = timeout_seconds
+        return cron.CronResult(0, {"ok": True}, project_dir)
+
+    monkeypatch.setattr(cron, "run_headless_auto", fake_run_headless_auto)
+
+    result = cron.main([str(cli_project), "--timeout", "7"])
+
+    assert result == 0
+    assert captured["project_dir"] == str(cli_project)
+    assert captured["timeout_seconds"] == 7

package/integrations/hermes/tests/test_directory_loader.py

@@ -0,0 +1,37 @@
+"""Directory-loader compatibility tests."""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+
+
+def load_plugin_directory(plugin_root: Path) -> ModuleType:
+    """Load the Hermes plugin the same way its directory loader does."""
+    init_file = plugin_root / "__init__.py"
+    if not init_file.exists():
+        raise FileNotFoundError(f"No __init__.py in {plugin_root}")
+
+    spec = importlib.util.spec_from_file_location(
+        "open_gsd_hermes_directory_loader",
+        init_file,
+        submodule_search_locations=[str(plugin_root)],
+    )
+    assert spec is not None
+    assert spec.loader is not None
+
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def test_plugin_root_supports_hermes_directory_loader() -> None:
+    plugin_root = Path(__file__).resolve().parents[1]
+
+    module = load_plugin_directory(plugin_root)
+
+    assert callable(module.register)
+    assert module.__all__ == ["register"]

package/integrations/hermes/tests/test_gsd_client_cache.py

@@ -0,0 +1,123 @@
+"""Unit tests for MCP client TTL cache (no subprocess)."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import time
+from unittest.mock import patch
+
+from open_gsd_hermes.config import GsdConfig
+from open_gsd_hermes.gsd_client import GsdMcpClient, GsdVersionError
+from open_gsd_hermes.types import ProgressSnapshot
+
+
+def test_progress_cache_ttl() -> None:
+    config = GsdConfig(cache_ttl_seconds=1)
+    client = GsdMcpClient(config)
+    calls = {"n": 0}
+
+    def fake_read(project_dir: str) -> ProgressSnapshot:
+        calls["n"] += 1
+        return ProgressSnapshot(phase="execute", blockers=[], next_action="")
+
+    with patch.object(client, "_read_progress_cli", side_effect=fake_read):
+        with patch.object(client, "ensure_version"):
+            client.progress("/tmp/p")
+            client.progress("/tmp/p")
+            assert calls["n"] == 1
+            time.sleep(1.1)
+            client.progress("/tmp/p")
+            assert calls["n"] == 2
+
+
+def test_invalidate_cache_only_removes_exact_project() -> None:
+    client = GsdMcpClient(GsdConfig(cache_ttl_seconds=60))
+    calls: dict[str, int] = {}
+
+    def fake_read(project_dir: str) -> ProgressSnapshot:
+        calls[project_dir] = calls.get(project_dir, 0) + 1
+        return ProgressSnapshot(phase="execute", blockers=[], next_action=project_dir)
+
+    with patch.object(client, "_read_progress_cli", side_effect=fake_read):
+        with patch.object(client, "ensure_version"):
+            client.progress("/tmp/app")
+            client.progress("/tmp/app-v2")
+
+            client.invalidate_cache("/tmp/app")
+
+            client.progress("/tmp/app-v2")
+            client.progress("/tmp/app")
+
+    assert calls["/tmp/app-v2"] == 1
+    assert calls["/tmp/app"] == 2
+
+
+def test_progress_falls_back_to_mcp_when_cli_binary_is_missing() -> None:
+    client = GsdMcpClient(GsdConfig())
+
+    with patch.object(client, "ensure_version", side_effect=FileNotFoundError("gsd")):
+        with patch.object(
+            client,
+            "_call_tool",
+            return_value={"phase": "execute", "nextAction": "from mcp"},
+        ) as call_tool:
+            progress = client.progress("/tmp/p")
+
+    assert progress.phase == "execute"
+    assert progress.next_action == "from mcp"
+    call_tool.assert_called_once_with(
+        "gsd_progress",
+        {"projectDir": "/tmp/p"},
+        check_version=False,
+        project_dir="/tmp/p",
+    )
+
+
+def test_progress_falls_back_to_mcp_when_cli_version_is_unsupported() -> None:
+    client = GsdMcpClient(GsdConfig())
+
+    with patch.object(client, "ensure_version", side_effect=GsdVersionError("old gsd")):
+        with patch.object(
+            client,
+            "_call_tool",
+            return_value={"phase": "execute", "nextAction": "from mcp"},
+        ) as call_tool:
+            progress = client.progress("/tmp/p")
+
+    assert progress.phase == "execute"
+    assert progress.next_action == "from mcp"
+    call_tool.assert_called_once_with(
+        "gsd_progress",
+        {"projectDir": "/tmp/p"},
+        check_version=False,
+        project_dir="/tmp/p",
+    )
+
+
+def test_progress_falls_back_to_mcp_when_cli_json_has_unexpected_shape() -> None:
+    client = GsdMcpClient(GsdConfig())
+    cli_result = subprocess.CompletedProcess(
+        args=["gsd", "read", "progress"],
+        returncode=0,
+        stdout=json.dumps(["unexpected"]),
+        stderr="",
+    )
+
+    with patch.object(client, "ensure_version"):
+        with patch("subprocess.run", return_value=cli_result):
+            with patch.object(
+                client,
+                "_call_tool",
+                return_value={"phase": "execute", "nextAction": "from mcp"},
+            ) as call_tool:
+                progress = client.progress("/tmp/p")
+
+    assert progress.phase == "execute"
+    assert progress.next_action == "from mcp"
+    call_tool.assert_called_once_with(
+        "gsd_progress",
+        {"projectDir": "/tmp/p"},
+        check_version=False,
+        project_dir="/tmp/p",
+    )

package/integrations/hermes/tests/test_gsd_client_execute.py

@@ -0,0 +1,35 @@
+"""Unit tests for MCP-backed GSD execution."""
+
+from __future__ import annotations
+
+from unittest.mock import patch
+
+from open_gsd_hermes.config import GsdConfig
+from open_gsd_hermes.gsd_client import GsdMcpClient, GsdVersionError
+
+
+def test_execute_falls_back_to_mcp_when_cli_version_is_unsupported() -> None:
+    client = GsdMcpClient(GsdConfig())
+
+    with patch.object(client, "_call_tool") as call_tool:
+        call_tool.side_effect = [
+            GsdVersionError("old gsd"),
+            {"sessionId": "session-1"},
+        ]
+
+        result = client.execute("/tmp/p")
+
+    assert result == {"sessionId": "session-1"}
+    assert call_tool.call_args_list[0].args == (
+        "gsd_execute",
+        {"projectDir": "/tmp/p", "command": "/gsd auto"},
+    )
+    assert call_tool.call_args_list[0].kwargs == {"project_dir": "/tmp/p"}
+    assert call_tool.call_args_list[1].args == (
+        "gsd_execute",
+        {"projectDir": "/tmp/p", "command": "/gsd auto"},
+    )
+    assert call_tool.call_args_list[1].kwargs == {
+        "check_version": False,
+        "project_dir": "/tmp/p",
+    }

package/integrations/hermes/tests/test_gsd_client_process_cwd.py

@@ -0,0 +1,22 @@
+"""Unit tests for MCP server process cwd selection."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+from open_gsd_hermes.config import GsdConfig
+from open_gsd_hermes.gsd_client import GsdMcpClient
+
+
+def test_ensure_process_starts_server_in_project_cwd(tmp_path) -> None:
+    client = GsdMcpClient(GsdConfig())
+    fake_proc = MagicMock()
+    fake_proc.poll.return_value = None
+
+    with patch.object(client, "_initialize") as initialize:
+        with patch("subprocess.Popen", return_value=fake_proc) as popen:
+            proc = client._ensure_process(str(tmp_path))
+
+    assert proc is fake_proc
+    initialize.assert_called_once_with()
+    assert popen.call_args.kwargs["cwd"] == str(tmp_path)

package/integrations/hermes/tests/test_gsd_client_timeout.py

@@ -0,0 +1,98 @@
+"""Unit tests for MCP stdio read timeouts."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from unittest.mock import patch
+
+import pytest
+
+from open_gsd_hermes.config import GsdConfig
+from open_gsd_hermes.gsd_client import GsdMcpClient, McpProtocolError
+
+
+def test_read_message_times_out_waiting_for_headers() -> None:
+    client = GsdMcpClient(GsdConfig(mcp_read_timeout_seconds=0.05))
+    proc = subprocess.Popen(
+        [sys.executable, "-c", "import time; time.sleep(10)"],
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+    client._proc = proc
+
+    try:
+        with pytest.raises(McpProtocolError, match="timed out"):
+            client._read_message()
+        assert client._proc is None
+        assert proc.poll() is not None
+    finally:
+        proc.kill()
+
+
+def test_read_message_times_out_waiting_for_body() -> None:
+    client = GsdMcpClient(GsdConfig(mcp_read_timeout_seconds=0.05))
+    proc = subprocess.Popen(
+        [
+            sys.executable,
+            "-c",
+            (
+                "import sys, time; "
+                "sys.stdout.buffer.write(b'Content-Length: 2\\r\\n\\r\\n{'); "
+                "sys.stdout.flush(); "
+                "time.sleep(10)"
+            ),
+        ],
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+    client._proc = proc
+
+    try:
+        with pytest.raises(McpProtocolError, match="timed out"):
+            client._read_message()
+        assert client._proc is None
+        assert proc.poll() is not None
+    finally:
+        proc.kill()
+
+
+def test_read_message_fails_without_respawning_when_stdout_closes_mid_body(
+    tmp_path,
+) -> None:
+    client = GsdMcpClient(GsdConfig(mcp_read_timeout_seconds=1))
+    proc = subprocess.Popen(
+        [
+            sys.executable,
+            "-c",
+            (
+                "import sys; "
+                "sys.stdout.buffer.write(b'Content-Length: 20\\r\\n\\r\\n{'); "
+                "sys.stdout.flush()"
+            ),
+        ],
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+    client._proc = proc
+    client._proc_cwd = str(tmp_path)
+
+    try:
+        with patch.object(
+            client,
+            "_ensure_process",
+            side_effect=AssertionError("read must not respawn MCP server"),
+        ) as ensure_process:
+            with pytest.raises(McpProtocolError, match="closed stdout"):
+                client._read_message()
+
+        ensure_process.assert_not_called()
+        assert client._proc is None
+        assert client._proc_cwd is None
+    finally:
+        if proc.poll() is None:
+            proc.kill()
+        proc.wait(timeout=1)

package/integrations/hermes/tests/test_memory.py

@@ -0,0 +1,59 @@
+"""Golden test for federated memory prefetch (6c)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from open_gsd_hermes.config import GsdConfig
+from open_gsd_hermes.gsd_client import GsdMcpClient
+from open_gsd_hermes.memory import GsdMemoryProvider
+
+GOLDEN = Path(__file__).parent / "golden" / "memory_prefetch.txt"
+
+
+def test_memory_prefetch_golden(tmp_path: Path) -> None:
+    memory_file = tmp_path / "MEMORY.md"
+    memory_file.write_text("User prefers concise Slack updates.\n", encoding="utf-8")
+
+    config = GsdConfig(hermes_memory_path=str(memory_file))
+    client = MagicMock(spec=GsdMcpClient)
+    client.memory_query.return_value = {
+        "memories": [{"content": "Auth uses JWT with refresh rotation"}],
+    }
+
+    provider = GsdMemoryProvider(config, client)
+    rendered = provider.prefetch("/tmp/project", query="auth")
+    expected = GOLDEN.read_text(encoding="utf-8").strip()
+    assert rendered.strip() == expected
+
+
+def test_memory_prefetch_ignores_empty_memory_results() -> None:
+    config = GsdConfig()
+    client = MagicMock(spec=GsdMcpClient)
+    client.memory_query.return_value = {"memories": []}
+
+    provider = GsdMemoryProvider(config, client)
+    rendered = provider.prefetch("/tmp/project", query="auth")
+
+    assert rendered == ""
+
+
+def test_memory_prefetch_keeps_multiple_gsd_memories_in_one_list() -> None:
+    config = GsdConfig()
+    client = MagicMock(spec=GsdMcpClient)
+    client.memory_query.return_value = {
+        "memories": [
+            {"content": "Auth uses JWT with refresh rotation"},
+            {"content": "Billing runs through Stripe"},
+        ],
+    }
+
+    provider = GsdMemoryProvider(config, client)
+    rendered = provider.prefetch("/tmp/project", query="auth")
+
+    assert rendered == (
+        "## GSD memories\n"
+        "- Auth uses JWT with refresh rotation\n"
+        "- Billing runs through Stripe"
+    )