@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.5fc22c6f

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,36 @@
+"""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_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,120 @@
+"""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,
+    )
+
+
+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,
+    )
+
+
+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,
+    )

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"
+    )

package/integrations/hermes/tests/test_read_cli_contract.py

@@ -0,0 +1,50 @@
+"""Contract test: gsd read progress against minimal-project fixture."""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+from pathlib import Path
+
+import pytest
+
+FIXTURE = Path(__file__).parent / "fixtures" / "minimal-project"
+REPO_ROOT = Path(__file__).resolve().parents[3]
+GSD_CLI = os.environ.get("GSD_CLI_PATH", "node")
+GSD_LOADER = os.environ.get(
+    "GSD_LOADER_PATH", str(REPO_ROOT / "dist" / "loader.js")
+)
+
+
+def _gsd_cmd(*args: str) -> list[str]:
+    if GSD_CLI == "node" or GSD_CLI.endswith("node"):
+        return [GSD_CLI, GSD_LOADER, *args]
+    return [GSD_CLI, *args]
+
+
+def test_read_cli_progress_fixture() -> None:
+    if not Path(GSD_LOADER).exists():
+        pytest.skip(f"GSD loader not built: {GSD_LOADER}")
+
+    result = subprocess.run(
+        _gsd_cmd(
+            "read",
+            "progress",
+            "--json",
+            "--project",
+            str(FIXTURE.resolve()),
+        ),
+        capture_output=True,
+        text=True,
+        check=False,
+        timeout=30,
+        cwd=str(REPO_ROOT),
+    )
+    assert result.returncode == 0, result.stderr or result.stdout
+    envelope = json.loads(result.stdout)
+    assert envelope["integration_version"] == 1
+    assert envelope["kind"] == "progress"
+    data = envelope["data"]
+    assert data.get("activeMilestone", {}).get("id") == "M001"
+    assert "Hermes Integration" in (data.get("activeMilestone", {}).get("title") or "")

package/integrations/hermes/tests/test_register.py

@@ -0,0 +1,56 @@
+"""Registration integration tests."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import Any, Callable
+from unittest.mock import MagicMock
+
+import open_gsd_hermes
+from open_gsd_hermes.config import GsdConfig
+from open_gsd_hermes.types import ProgressSnapshot
+
+
+class FakeContext:
+    def __init__(self) -> None:
+        self.commands: dict[str, Callable[..., Any]] = {}
+        self.hooks: dict[str, Callable[..., Any]] = {}
+
+    def register_command(self, name: str, handler: Callable[..., Any]) -> None:
+        self.commands[name] = handler
+
+    def register_hook(self, name: str, handler: Callable[..., Any]) -> None:
+        self.hooks[name] = handler
+
+    def register_memory_provider(self, _provider: Any) -> None:
+        pass
+
+    def dispatch_tool(self, _name: str, _arguments: dict[str, Any]) -> None:
+        pass
+
+
+def test_pre_llm_call_uses_bound_session_project(tmp_path: Path, monkeypatch) -> None:
+    default_project = tmp_path / "default"
+    bound_project = tmp_path / "bound"
+    (default_project / ".gsd").mkdir(parents=True)
+    (bound_project / ".gsd").mkdir(parents=True)
+    client = MagicMock()
+    client.progress.return_value = ProgressSnapshot(phase="execute")
+    ctx = FakeContext()
+
+    monkeypatch.setenv("HERMES_SESSION_KEY", "agent:main:cli:direct:local")
+    monkeypatch.setattr(
+        open_gsd_hermes,
+        "load_config",
+        lambda: GsdConfig(default_project=str(default_project)),
+    )
+    monkeypatch.setattr(open_gsd_hermes, "GsdMcpClient", lambda _config: client)
+
+    open_gsd_hermes.register(ctx)
+    bind_result = asyncio.run(ctx.commands["gsd"](f"bind {bound_project}"))
+    hook_result = ctx.hooks["pre_llm_call"]()
+
+    assert bind_result == f"Bound to `{bound_project.resolve()}`"
+    assert hook_result["context"].startswith("## GSD Project Snapshot")
+    client.progress.assert_called_once_with(str(bound_project.resolve()))

package/integrations/hermes/tests/test_snapshot.py

@@ -0,0 +1,53 @@
+"""Golden snapshot test for pre_llm_call formatting."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from open_gsd_hermes.formatting import format_ref
+from open_gsd_hermes.snapshot import format_snapshot
+from open_gsd_hermes.types import ProgressSnapshot
+
+GOLDEN = Path(__file__).parent / "golden" / "snapshot.txt"
+
+
+def test_snapshot_golden() -> None:
+    progress = ProgressSnapshot(
+        active_milestone={"id": "M001", "title": "Hermes Integration"},
+        active_slice={"id": "S01", "title": "Gateway MVP"},
+        active_task={"id": "T01", "title": "Plugin scaffold"},
+        phase="execute",
+        milestones={"total": 1, "done": 0, "active": 1, "pending": 0, "parked": 0},
+        slices={"total": 0, "done": 0, "active": 0, "pending": 0},
+        tasks={"total": 0, "done": 0, "pending": 0},
+        requirements={"active": 2, "validated": 0, "deferred": 0, "outOfScope": 0},
+        blockers=[],
+        next_action="Run contract tests for binding and snapshot golden.",
+    )
+    rendered = format_snapshot(progress)
+    expected = GOLDEN.read_text(encoding="utf-8").strip()
+    # Phase maps "execution" -> execute in MCP; golden uses execute
+    assert rendered.strip() == expected
+
+
+def test_snapshot_omits_duplicate_id_when_title_missing() -> None:
+    progress = ProgressSnapshot(
+        active_milestone={"id": "M001"},
+        active_slice={"id": "S01", "title": ""},
+        active_task={"id": "T01", "title": "Plugin scaffold"},
+        phase="execute",
+    )
+
+    rendered = format_snapshot(progress)
+
+    assert "Active milestone: M001" in rendered
+    assert "Active slice: S01" in rendered
+    assert "M001: M001" not in rendered
+    assert "S01: S01" not in rendered
+
+
+def test_format_ref_supports_snapshot_and_transition_styles() -> None:
+    ref = {"id": "M001", "title": "Hermes Integration"}
+
+    assert format_ref(ref) == "M001: Hermes Integration"
+    assert format_ref(ref, include_title=False) == "M001"