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

package/integrations/hermes/tests/test_new_milestone_command.py

@@ -0,0 +1,313 @@
+"""Tests for /gsd new-milestone command routing and the cross-command guards.
+
+Covers the issue #1162 design:
+- _cmd_new_milestone: input parsing (bare text, --file, empty, --auto rejected),
+  co-run guard (reject if auto RUNNING/BLOCKED), spawn + ack, help text.
+- _cmd_auto: symmetric co-run guard (reject if milestone run active).
+- _cmd_cancel: routes to cancel_milestone() when a milestone subprocess is active.
+- _cmd_reply: routes planning-blocker replies to client stdin when milestone
+  subprocess is active with a pending blocker.
+
+Async handlers are driven with asyncio.run, matching the convention in
+test_register.py.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+
+from open_gsd_hermes.commands import GsdCommandRouter
+from open_gsd_hermes.config import GsdConfig
+from open_gsd_hermes.supervisor import SupervisorContext, SupervisorState
+from open_gsd_hermes.types import BindingContext
+
+
+def _make_router(
+    *,
+    project_dir: str | None = "/proj",
+    supervisor_state: SupervisorState = SupervisorState.IDLE,
+    milestone_active: bool = False,
+    milestone_blocker_id: str | None = None,
+) -> tuple[GsdCommandRouter, MagicMock]:
+    """Build a router with a MagicMock client + bind store for isolated testing."""
+    config = GsdConfig(default_project=project_dir)
+    client = MagicMock()
+    client.milestone_active.return_value = milestone_active
+    client.milestone_session_id.return_value = "S-1" if milestone_active else None
+    client.milestone_pending_blocker_id.return_value = milestone_blocker_id
+    bind_store = MagicMock()
+    supervisor = MagicMock()
+    notifications = MagicMock()
+
+    sup_ctx_holder: dict[str, SupervisorContext] = {
+        "ctx": SupervisorContext(
+            session_id=None,
+            project_dir=project_dir,
+            state=supervisor_state,
+        )
+    }
+
+    def get_session_key() -> str:
+        return "agent:main:cli:direct:local"
+
+    def get_binding_ctx() -> BindingContext:
+        return BindingContext(cwd=project_dir)
+
+    def get_supervisor_ctx() -> SupervisorContext:
+        return sup_ctx_holder["ctx"]
+
+    def set_supervisor_ctx(ctx: SupervisorContext) -> None:
+        sup_ctx_holder["ctx"] = ctx
+
+    def get_platform_channel() -> tuple[str | None, str | None]:
+        return "cli", "local"
+
+    router = GsdCommandRouter(
+        config,
+        client,
+        bind_store,
+        supervisor,
+        get_session_key,
+        get_binding_ctx,
+        get_supervisor_ctx,
+        set_supervisor_ctx,
+        get_platform_channel,
+        notifications,
+    )
+    return router, client
+
+
+@pytest.fixture
+def project(tmp_path: Path) -> Path:
+    """A directory that looks like a GSD project (.gsd/ present)."""
+    (tmp_path / ".gsd").mkdir()
+    return tmp_path
+
+
+def run(router: GsdCommandRouter, args: str) -> str:
+    return asyncio.run(router.handle(args))
+
+
+# ---------------------------------------------------------------------------
+# _cmd_new_milestone — input parsing & usage
+# ---------------------------------------------------------------------------
+
+
+def test_new_milestone_bare_text_passes_context_text(project: Path) -> None:
+    router, client = _make_router(project_dir=str(project))
+    result = run(router, "new-milestone Build a REST API with auth")
+    client.create_milestone.assert_called_once()
+    kwargs = client.create_milestone.call_args.kwargs
+    assert kwargs.get("context_text") == "Build a REST API with auth"
+    assert kwargs.get("context_file") is None
+    assert "started" in result.lower() or "S-1" in result
+
+
+def test_new_milestone_terminal_callback_clears_local_session_id(
+    project: Path,
+) -> None:
+    router, client = _make_router(project_dir=str(project))
+    client.create_milestone.return_value = "milestone-4242"
+
+    run(router, "new-milestone Build a REST API with auth")
+    ctx = router._get_supervisor_ctx()  # type: ignore[attr-defined]
+    ctx.pending_blocker_id = "blk-1"
+    assert ctx.session_id == "milestone-4242"
+
+    on_terminal = client.create_milestone.call_args.kwargs["on_terminal"]
+    on_terminal("complete")
+
+    ctx = router._get_supervisor_ctx()  # type: ignore[attr-defined]
+    assert ctx.state == SupervisorState.COMPLETE
+    assert ctx.session_id is None
+    assert ctx.pending_blocker_id is None
+    assert ctx.notified_terminal is True
+
+    result = run(router, "reply stale response")
+    client.resolve_blocker.assert_not_called()
+    assert "no active" in result.lower()
+
+
+def test_new_milestone_file_flag_passes_context_file(project: Path) -> None:
+    router, client = _make_router(project_dir=str(project))
+    spec = project / "spec.md"
+    spec.write_text("milestone spec", encoding="utf-8")
+    run(router, f"new-milestone --file {spec}")
+    kwargs = client.create_milestone.call_args.kwargs
+    assert kwargs.get("context_file") == str(spec)
+    assert kwargs.get("context_text") is None
+
+
+def test_new_milestone_file_flag_resolves_relative_path_from_project(
+    project: Path,
+) -> None:
+    router, client = _make_router(project_dir=str(project))
+    spec = project / "spec.md"
+    spec.write_text("milestone spec", encoding="utf-8")
+    run(router, "new-milestone --file spec.md")
+    kwargs = client.create_milestone.call_args.kwargs
+    assert kwargs.get("context_file") == str(spec)
+    assert kwargs.get("context_text") is None
+
+
+def test_new_milestone_file_flag_rejects_missing_file(project: Path) -> None:
+    router, client = _make_router(project_dir=str(project))
+    result = run(router, "new-milestone --file missing.md")
+    assert "not found" in result.lower()
+    client.create_milestone.assert_not_called()
+
+
+def test_new_milestone_empty_returns_usage(project: Path) -> None:
+    router, client = _make_router(project_dir=str(project))
+    result = run(router, "new-milestone")
+    assert "usage" in result.lower()
+    client.create_milestone.assert_not_called()
+
+
+def test_new_milestone_rejects_auto_flag(project: Path) -> None:
+    """--auto chaining is out of scope; execution stays with /gsd auto."""
+    router, client = _make_router(project_dir=str(project))
+    result = run(router, "new-milestone --auto some spec")
+    assert "auto" in result.lower()
+    client.create_milestone.assert_not_called()
+
+
+# ---------------------------------------------------------------------------
+# Co-run guards (Q2 + Q9 symmetry)
+# ---------------------------------------------------------------------------
+
+
+def test_new_milestone_rejects_when_auto_running(project: Path) -> None:
+    """Co-run guard: refuse if an auto session is RUNNING or BLOCKED."""
+    router, client = _make_router(
+        project_dir=str(project),
+        supervisor_state=SupervisorState.RUNNING,
+    )
+    result = run(router, "new-milestone some spec")
+    assert "cancel" in result.lower() or "running" in result.lower()
+    client.create_milestone.assert_not_called()
+
+
+def test_new_milestone_rejects_when_auto_blocked(project: Path) -> None:
+    router, client = _make_router(
+        project_dir=str(project),
+        supervisor_state=SupervisorState.BLOCKED,
+    )
+    result = run(router, "new-milestone some spec")
+    assert "cancel" in result.lower() or "running" in result.lower()
+    client.create_milestone.assert_not_called()
+
+
+def test_new_milestone_prioritizes_milestone_guard_over_auto_state(
+    project: Path,
+) -> None:
+    """A duplicate milestone command should report the milestone guard."""
+    router, client = _make_router(
+        project_dir=str(project),
+        supervisor_state=SupervisorState.RUNNING,
+        milestone_active=True,
+    )
+    result = run(router, "new-milestone some spec")
+    assert "milestone creation is in progress" in result.lower()
+    assert "auto is running" not in result.lower()
+    client.create_milestone.assert_not_called()
+
+
+def test_new_milestone_allows_when_auto_complete(project: Path) -> None:
+    """A terminal auto state does not block milestone creation."""
+    router, client = _make_router(
+        project_dir=str(project),
+        supervisor_state=SupervisorState.COMPLETE,
+    )
+    run(router, "new-milestone some spec")
+    client.create_milestone.assert_called_once()
+
+
+def test_auto_rejects_when_milestone_active(project: Path) -> None:
+    """Symmetric guard: /gsd auto refuses if a milestone run is in progress."""
+    router, client = _make_router(
+        project_dir=str(project),
+        milestone_active=True,
+    )
+    result = run(router, "auto")
+    assert "cancel" in result.lower() or "milestone" in result.lower()
+    client.execute.assert_not_called()
+
+
+# ---------------------------------------------------------------------------
+# _cmd_cancel — milestone branch
+# ---------------------------------------------------------------------------
+
+
+def test_cancel_routes_to_cancel_milestone_when_milestone_active(
+    project: Path,
+) -> None:
+    router, client = _make_router(
+        project_dir=str(project),
+        milestone_active=True,
+    )
+    run(router, "cancel")
+    client.cancel_milestone.assert_called_once()
+
+
+def test_cancel_routes_to_mcp_cancel_when_only_auto_active(project: Path) -> None:
+    """When no milestone proc is active, cancel falls back to the MCP path."""
+    router, client = _make_router(
+        project_dir=str(project),
+        supervisor_state=SupervisorState.RUNNING,
+    )
+    # Give the auto session an id so the MCP cancel-by-session path is taken
+    run(router, "cancel")
+    client.cancel_milestone.assert_not_called()
+    assert client.cancel.called or client.cancel_by_project.called
+
+
+# ---------------------------------------------------------------------------
+# _cmd_reply — milestone-blocker branch
+# ---------------------------------------------------------------------------
+
+
+def test_reply_routes_to_milestone_blocker_when_milestone_pending(
+    project: Path,
+) -> None:
+    router, client = _make_router(
+        project_dir=str(project),
+        milestone_active=True,
+        milestone_blocker_id="blk-9",
+    )
+    result = run(router, "reply use option B")
+    client.respond_to_milestone_blocker.assert_called_once_with("use option B")
+    assert "sent" in result.lower()
+
+
+def test_reply_does_not_fall_through_to_mcp_when_milestone_active_no_blocker(
+    project: Path,
+) -> None:
+    """Active milestone without a pending blocker must not hit MCP resolve_blocker."""
+    router, client = _make_router(
+        project_dir=str(project),
+        milestone_active=True,
+        milestone_blocker_id=None,
+    )
+    router._get_supervisor_ctx().session_id = "milestone-1"  # type: ignore[attr-defined]
+    result = run(router, "reply some answer")
+    client.respond_to_milestone_blocker.assert_not_called()
+    client.resolve_blocker.assert_not_called()
+    assert "no pending blocker" in result.lower()
+
+
+def test_reply_falls_back_to_mcp_when_no_milestone(project: Path) -> None:
+    """No milestone proc → existing MCP resolve_blocker path (needs a session)."""
+    router, client = _make_router(
+        project_dir=str(project),
+        supervisor_state=SupervisorState.BLOCKED,
+    )
+    # set a session id so the existing reply path doesn't short-circuit
+    router._get_supervisor_ctx().session_id = "auto-1"  # type: ignore[attr-defined]
+    run(router, "reply some answer")
+    client.respond_to_milestone_blocker.assert_not_called()
+    client.resolve_blocker.assert_called_once()

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"