Skip to content

Codebase intelligence for AI and humans: code health scores, auto-generated docs, git analytics, dead code detection, and architectural decisions via MCP.

6.6 KB
Raw Blame
"""Tests for the MCP tool-surface REST endpoints."""

from __future__ import annotations

import pytest

from repowise.server.mcp_server._tool_selection import (
    describe_tool_surface,
    set_tool_override,
)


def test_describe_tool_surface_single_repo(tmp_path, monkeypatch):
    from repowise.server.mcp_server import _tool_selection

    monkeypatch.setattr(_tool_selection, "_is_workspace", lambda _path: False)
    (tmp_path / ".repowise").mkdir()
    surface = describe_tool_surface(str(tmp_path))

    assert surface["is_workspace"] is False
    assert surface["override"] is None
    names = {t["name"] for t in surface["tools"]}
    # Core tools present and enabled; workspace-only present but disabled.
    assert {"get_answer", "get_context", "get_blast_radius"} <= names
    by_name = {t["name"]: t for t in surface["tools"]}
    assert by_name["get_answer"]["enabled"] is True
    assert by_name["get_answer"]["tier"] == "canonical"
    assert by_name["get_answer"]["artifact_type"] == "answer"
    assert by_name["get_answer"]["presentation"] == "answer"
    assert by_name["get_answer"]["safety"] == "read_only"
    assert by_name["get_risk"]["evidence_basis"] == "measured"
    assert by_name["list_repos"]["tier"] == "utility"
    assert by_name["list_repos"]["eligible"] is False
    assert by_name["list_repos"]["enabled"] is False
    assert by_name["get_blast_radius"]["requires_workspace"] is True
    assert by_name["get_blast_radius"]["enabled"] is False
    # Opt-in tools registered but off by default.
    assert by_name["get_execution_flows"]["default"] is False
    assert by_name["get_execution_flows"]["enabled"] is False
    # Every tool carries a one-line description.
    assert all(t["description"] for t in surface["tools"])


def test_set_tool_override_opt_in_and_clear(tmp_path):
    (tmp_path / ".repowise").mkdir()

    set_tool_override(str(tmp_path), ["+get_execution_flows"])
    surface = describe_tool_surface(str(tmp_path))
    by_name = {t["name"]: t for t in surface["tools"]}
    assert by_name["get_execution_flows"]["enabled"] is True
    assert surface["override"] == ["+get_execution_flows"]

    # Clearing removes the override and the mcp block entirely.
    set_tool_override(str(tmp_path), None)
    from repowise.core.repo_config import load_repo_config

    assert "mcp" not in load_repo_config(str(tmp_path))
    assert describe_tool_surface(str(tmp_path))["override"] is None


def test_set_tool_override_preserves_other_config(tmp_path):
    rw = tmp_path / ".repowise"
    rw.mkdir()
    (rw / "config.yaml").write_text("provider: openai\nmodel: gpt-5\n", encoding="utf-8")

    set_tool_override(str(tmp_path), ["+get_dependency_path"])

    from repowise.core.repo_config import load_repo_config

    cfg = load_repo_config(str(tmp_path))
    assert cfg["provider"] == "openai"
    assert cfg["model"] == "gpt-5"
    assert cfg["mcp"]["tools"] == ["+get_dependency_path"]


@pytest.mark.asyncio
async def test_router_get_and_patch(tmp_path, monkeypatch):
    """The REST endpoints resolve a repo path, read, and persist the surface."""
    from repowise.server.routers import mcp as mcp_router

    (tmp_path / ".repowise").mkdir()

    async def fake_repo_path(_request, repo_id):
        return str(tmp_path) if repo_id == "r1" else None

    monkeypatch.setattr(mcp_router, "_repo_path_for", fake_repo_path)

    got = await mcp_router.get_tool_surface(request=None, repo_id="r1")
    assert got.repo_id == "r1"
    assert any(t.name == "get_answer" and t.enabled for t in got.tools)
    answer = next(t for t in got.tools if t.name == "get_answer")
    assert answer.artifact_type == "answer"
    assert answer.presentation == "answer"
    assert answer.safety == "read_only"

    from repowise.server.schemas import UpdateMcpToolsRequest

    updated = await mcp_router.update_tool_surface(
        body=UpdateMcpToolsRequest(repo_id="r1", tools=["+get_dependency_path"]),
        request=None,
    )
    assert any(t.name == "get_dependency_path" and t.enabled for t in updated.tools)


@pytest.mark.asyncio
async def test_router_patch_routes_body_repo_id_to_workspace_database(tmp_path, session_factory):
    """A body-only repo ID must select that repo's workspace database."""
    from fastapi import FastAPI
    from httpx import ASGITransport, AsyncClient
    from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
    from sqlalchemy.pool import StaticPool

    from repowise.core.persistence import crud
    from repowise.core.persistence.database import get_session, init_db
    from repowise.server.deps import verify_api_key
    from repowise.server.routers import mcp as mcp_router

    repo_id = "workspace-repo"
    repo_path = tmp_path / repo_id
    (repo_path / ".repowise").mkdir(parents=True)

    workspace_engine = create_async_engine(
        "sqlite+aiosqlite:///:memory:",
        connect_args={"check_same_thread": False},
        poolclass=StaticPool,
    )
    await init_db(workspace_engine)
    workspace_factory = async_sessionmaker(
        workspace_engine, expire_on_commit=False, class_=AsyncSession
    )
    async with get_session(workspace_factory) as workspace_session:
        await crud.upsert_repository(
            workspace_session,
            repo_id=repo_id,
            name="workspace-repo",
            local_path=str(repo_path),
        )

    app = FastAPI()
    app.state.session_factory = session_factory
    app.state.workspace_sessions = {repo_id: workspace_factory}
    app.dependency_overrides[verify_api_key] = lambda: None
    app.include_router(mcp_router.router)

    try:
        transport = ASGITransport(app=app)
        async with AsyncClient(transport=transport, base_url="http://test") as client:
            response = await client.patch(
                "/api/mcp/tools",
                json={"repo_id": repo_id, "tools": ["+get_dependency_path"]},
            )

        assert response.status_code == 200
        assert response.json()["repo_id"] == repo_id
        assert response.json()["override"] == ["+get_dependency_path"]
    finally:
        await workspace_engine.dispose()


@pytest.mark.asyncio
async def test_router_patch_unknown_repo_404(monkeypatch):
    from fastapi import HTTPException

    from repowise.server.routers import mcp as mcp_router
    from repowise.server.schemas import UpdateMcpToolsRequest

    async def fake_repo_path(_request, repo_id):
        return None

    monkeypatch.setattr(mcp_router, "_repo_path_for", fake_repo_path)

    with pytest.raises(HTTPException) as exc:
        await mcp_router.update_tool_surface(
            body=UpdateMcpToolsRequest(repo_id="missing", tools=None),
            request=None,
        )
    assert exc.value.status_code == 404