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.

24.7 KB
Raw Blame
"""Phase 4A decision-graph integration tests for MCP tools.

Tests the bounded get_governing_decisions usage in:
  - get_context: governing_decisions field + decision_records titles
  - get_risk: directive.governance_risk for PR mode
  - get_overview: key_decisions section
"""

from __future__ import annotations

import json
from datetime import UTC, datetime

import pytest
from sqlalchemy import delete
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
from sqlalchemy.pool import StaticPool

from repowise.core.persistence.database import init_db
from repowise.core.persistence.models import (
    DecisionEdge,
    DecisionNodeLink,
    DecisionRecord,
    GitMetadata,
    GraphNode,
    Page,
    Repository,
)
from repowise.core.persistence.search import FullTextSearch
from repowise.core.persistence.vector_store import InMemoryVectorStore
from repowise.core.providers.embedding.base import MockEmbedder

_NOW = datetime(2026, 3, 19, 12, 0, 0, tzinfo=UTC)


# ---------------------------------------------------------------------------
# Engine / session fixtures (mirrors test_mcp.py)
# ---------------------------------------------------------------------------


@pytest.fixture
async def engine():
    eng = create_async_engine(
        "sqlite+aiosqlite:///:memory:",
        connect_args={"check_same_thread": False},
        poolclass=StaticPool,
    )
    await init_db(eng)
    yield eng
    await eng.dispose()


@pytest.fixture
async def factory(engine):
    return async_sessionmaker(engine, expire_on_commit=False, class_=AsyncSession)


@pytest.fixture
async def session(factory):
    async with factory() as s:
        yield s
        await s.commit()


@pytest.fixture
async def fts(engine):
    f = FullTextSearch(engine)
    await f.ensure_index()
    return f


@pytest.fixture
async def vector_store():
    embedder = MockEmbedder()
    vs = InMemoryVectorStore(embedder=embedder)
    yield vs
    await vs.close()


# ---------------------------------------------------------------------------
# DB seed — includes DecisionNodeLink rows so graph queries work
# ---------------------------------------------------------------------------


@pytest.fixture
async def repo_id(session: AsyncSession) -> str:
    repo = Repository(
        id="repo1",
        name="test-repo",
        url="https://github.com/example/test-repo",
        local_path="/tmp/test-repo",
        default_branch="main",
        settings_json="{}",
        created_at=_NOW,
        updated_at=_NOW,
    )
    session.add(repo)
    await session.flush()
    return repo.id


@pytest.fixture
async def decision_db(session: AsyncSession, repo_id: str) -> str:
    """Seed pages, graph nodes, decisions, node links, and decision edges."""
    rid = repo_id

    # Pages
    pages = [
        Page(
            id="repo_overview:test-repo",
            repository_id=rid,
            page_type="repo_overview",
            title="Test Repo Overview",
            content="# Test Repo\n\nA comprehensive test repository.",
            target_path="test-repo",
            source_hash="abc123",
            model_name="mock",
            provider_name="mock",
            generation_level=6,
            confidence=1.0,
            freshness_status="fresh",
            metadata_json="{}",
            created_at=_NOW,
            updated_at=_NOW,
        ),
        Page(
            id="file_page:src/auth/service.py",
            repository_id=rid,
            page_type="file_page",
            title="Auth Service",
            content="# AuthService",
            target_path="src/auth/service.py",
            source_hash="file1",
            model_name="mock",
            provider_name="mock",
            generation_level=2,
            confidence=0.85,
            freshness_status="fresh",
            metadata_json="{}",
            created_at=_NOW,
            updated_at=_NOW,
        ),
        Page(
            id="file_page:src/db/models.py",
            repository_id=rid,
            page_type="file_page",
            title="DB Models",
            content="# DB Models",
            target_path="src/db/models.py",
            source_hash="file2",
            model_name="mock",
            provider_name="mock",
            generation_level=2,
            confidence=0.75,
            freshness_status="fresh",
            metadata_json="{}",
            created_at=_NOW,
            updated_at=_NOW,
        ),
    ]
    for p in pages:
        session.add(p)

    # Graph nodes
    nodes = [
        GraphNode(
            id="gn1",
            repository_id=rid,
            node_id="src/auth/service.py",
            node_type="file",
            language="python",
            symbol_count=2,
            is_entry_point=True,
            pagerank=0.85,
            betweenness=0.5,
            community_id=1,
            created_at=_NOW,
        ),
        GraphNode(
            id="gn2",
            repository_id=rid,
            node_id="src/db/models.py",
            node_type="file",
            language="python",
            symbol_count=1,
            is_entry_point=False,
            pagerank=0.6,
            betweenness=0.3,
            community_id=2,
            created_at=_NOW,
        ),
    ]
    for n in nodes:
        session.add(n)

    # Git metadata
    git_metas = [
        GitMetadata(
            id="gm1",
            repository_id=rid,
            file_path="src/auth/service.py",
            commit_count_total=42,
            commit_count_90d=8,
            commit_count_30d=3,
            first_commit_at=datetime(2025, 1, 1, tzinfo=UTC),
            last_commit_at=datetime(2026, 3, 15, tzinfo=UTC),
            primary_owner_name="Alice",
            primary_owner_email="[email protected]",
            primary_owner_commit_pct=0.65,
            top_authors_json=json.dumps([{"name": "Alice", "count": 27}]),
            significant_commits_json=json.dumps([
                {"sha": "abc1", "date": "2026-03-15", "message": "Refactor auth", "author": "Alice"},
            ]),
            co_change_partners_json=json.dumps([
                {"file_path": "src/db/models.py", "count": 3},
            ]),
            is_hotspot=True,
            is_stable=False,
            churn_percentile=0.92,
            age_days=443,
            created_at=_NOW,
            updated_at=_NOW,
        ),
    ]
    for g in git_metas:
        session.add(g)

    # Decision records
    # dec_active: active with low staleness — NOT a governance risk
    # dec_stale: active with high staleness — IS a governance risk (stale_governance)
    # dec_superseded: superseded — IS a governance risk (superseded_decision)
    decisions = [
        DecisionRecord(
            id="dec_active",
            repository_id=rid,
            title="Use JWT for authentication",
            status="active",
            context="Auth context",
            decision="Use JWT",
            rationale="Scalable",
            alternatives_json="[]",
            consequences_json="[]",
            affected_files_json=json.dumps(["src/auth/service.py"]),
            affected_modules_json=json.dumps(["src/auth"]),
            tags_json="[]",
            source="readme_mining",
            confidence=0.9,
            staleness_score=0.1,
            verification="exact",
            created_at=_NOW,
            updated_at=_NOW,
        ),
        DecisionRecord(
            id="dec_stale",
            repository_id=rid,
            title="Use sessions (stale)",
            status="active",
            context="Old auth context",
            decision="Use sessions",
            rationale="Simple",
            alternatives_json="[]",
            consequences_json="[]",
            affected_files_json=json.dumps(["src/auth/service.py"]),
            affected_modules_json="[]",
            tags_json="[]",
            source="readme_mining",
            confidence=0.5,
            staleness_score=0.8,  # high staleness → governance risk
            verification="fuzzy",
            created_at=_NOW,
            updated_at=_NOW,
        ),
        DecisionRecord(
            id="dec_superseded",
            repository_id=rid,
            title="Use basic auth (superseded)",
            status="superseded",
            context="Old auth context",
            decision="Use basic auth",
            rationale="Simple initially",
            alternatives_json="[]",
            consequences_json="[]",
            affected_files_json=json.dumps(["src/auth/service.py"]),
            affected_modules_json="[]",
            tags_json="[]",
            source="readme_mining",
            confidence=0.4,
            staleness_score=0.0,
            verification="unverified",
            created_at=_NOW,
            updated_at=_NOW,
        ),
        DecisionRecord(
            id="dec_db",
            repository_id=rid,
            title="Use SQLAlchemy as ORM",
            status="active",
            context="DB context",
            decision="Use SQLAlchemy",
            rationale="Mature",
            alternatives_json="[]",
            consequences_json="[]",
            affected_files_json=json.dumps(["src/db/models.py"]),
            affected_modules_json=json.dumps(["src/db"]),
            tags_json="[]",
            source="git_archaeology",
            confidence=0.7,
            staleness_score=0.0,
            verification="exact",
            created_at=_NOW,
            updated_at=_NOW,
        ),
    ]
    for d in decisions:
        session.add(d)

    await session.flush()

    # Every one of these is accepted. The status column alone no longer makes a
    # record govern: the surfaces under test join the acceptance, so a fixture
    # that only sets the column would exercise the candidate path throughout
    # and prove nothing about governance.
    from repowise.core.persistence.crud.authority import (
        accept_decision,
        record_acceptance,
    )

    for d in decisions:
        seeded = d.staleness_score
        await accept_decision(session, d, accepter="test", evidence=[f"seed:{d.id}"])
        # Accepting rescores from the stored git metadata, which this fixture
        # has none of; the seeded score is the state under test.
        d.staleness_score = seeded
    superseded = next(d for d in decisions if d.id == "dec_superseded")
    await record_acceptance(
        session,
        superseded,
        action="superseded",
        currency="superseded",
        accepter="test",
        kind="person",
        evidence=["seed:dec_superseded"],
    )
    await session.flush()

    # Accepting a record now mirrors its scope into the graph, so clear that
    # before writing the links this fixture wants: it states the graph
    # exactly, rather than layering on whatever the scope arrays imply.
    await session.execute(
        delete(DecisionNodeLink).where(DecisionNodeLink.repository_id == rid)
    )
    await session.flush()

    # DecisionNodeLink rows — the graph truth used by get_governing_decisions
    links = [
        DecisionNodeLink(
            repository_id=rid,
            decision_id="dec_active",
            node_id="src/auth/service.py",
            link_type="file",
            created_at=_NOW,
        ),
        DecisionNodeLink(
            repository_id=rid,
            decision_id="dec_stale",
            node_id="src/auth/service.py",
            link_type="file",
            created_at=_NOW,
        ),
        DecisionNodeLink(
            repository_id=rid,
            decision_id="dec_superseded",
            node_id="src/auth/service.py",
            link_type="file",
            created_at=_NOW,
        ),
        DecisionNodeLink(
            repository_id=rid,
            decision_id="dec_active",
            node_id="src/auth",
            link_type="module",
            created_at=_NOW,
        ),
        DecisionNodeLink(
            repository_id=rid,
            decision_id="dec_db",
            node_id="src/db/models.py",
            link_type="file",
            created_at=_NOW,
        ),
        DecisionNodeLink(
            repository_id=rid,
            decision_id="dec_db",
            node_id="src/db",
            link_type="module",
            created_at=_NOW,
        ),
    ]
    for lnk in links:
        session.add(lnk)

    # DecisionEdge: dec_active supersedes dec_superseded
    edge = DecisionEdge(
        repository_id=rid,
        src_decision_id="dec_active",
        dst_decision_id="dec_superseded",
        kind="supersedes",
        confidence=0.8,
        evidence="JWT supersedes basic auth",
        created_at=_NOW,
    )
    session.add(edge)

    # DecisionEdge: conflicts_with between dec_active and dec_stale
    conflict_edge = DecisionEdge(
        repository_id=rid,
        src_decision_id="dec_stale",
        dst_decision_id="dec_db",
        kind="conflicts_with",
        confidence=0.6,
        evidence="Conflicting auth approaches",
        created_at=_NOW,
    )
    session.add(conflict_edge)

    await session.flush()
    return rid


@pytest.fixture
async def setup_mcp_decisions(factory, fts, vector_store, decision_db):
    """Configure MCP global state for decision-graph tests."""
    import repowise.server.mcp_server as mcp_mod

    mcp_mod._session_factory = factory
    mcp_mod._fts = fts
    mcp_mod._vector_store = vector_store
    mcp_mod._decision_store = InMemoryVectorStore(embedder=MockEmbedder())
    mcp_mod._repo_path = "/tmp/test-repo"

    yield decision_db

    mcp_mod._session_factory = None
    mcp_mod._fts = None
    mcp_mod._vector_store = None
    mcp_mod._decision_store = None
    mcp_mod._repo_path = None
    mcp_mod._registry = None
    mcp_mod._workspace_root = None


# ---------------------------------------------------------------------------
# Task 1: get_context — decisions are opt-in (include=["decisions"])
# ---------------------------------------------------------------------------


@pytest.mark.asyncio
async def test_get_context_decisions_omitted_by_default(setup_mcp_decisions):
    """The default triage card carries no decision fields — they're opt-in.

    The enriched ``governing_decisions`` form (id/staleness/verification) was
    dropped entirely; an agent that wants rationale calls get_why directly.
    """
    from repowise.server.mcp_server import get_context

    result = await get_context(["src/auth/service.py"], include=["docs", "freshness"])
    t = result["targets"]["src/auth/service.py"]

    assert "decision_records" not in t
    assert "decision_records_hint" not in t
    assert "governing_decisions" not in t


@pytest.mark.asyncio
async def test_get_context_decisions_opt_in_titles(setup_mcp_decisions):
    """include=["decisions"] returns a lightweight titles list + hint only."""
    from repowise.server.mcp_server import get_context

    result = await get_context(["src/auth/service.py"], include=["docs", "decisions"])
    t = result["targets"]["src/auth/service.py"]

    assert "decision_records" in t
    titles = t["decision_records"]
    assert isinstance(titles, list)
    assert 1 <= len(titles) <= 3
    assert "Use JWT for authentication" in titles
    assert "decision_records_hint" in t

    # The heavy enriched objects are no longer emitted.
    assert "governing_decisions" not in t


@pytest.mark.asyncio
async def test_get_context_decision_titles_sorted_by_confidence(setup_mcp_decisions):
    """decision_records titles are highest-confidence first."""
    from repowise.server.mcp_server import get_context

    result = await get_context(["src/auth/service.py"], include=["decisions"])
    t = result["targets"]["src/auth/service.py"]
    titles = t.get("decision_records", [])
    # dec_active (conf 0.9) outranks dec_stale (0.5) and dec_superseded (0.4),
    # so its title leads when all three govern the file.
    if "Use JWT for authentication" in titles and len(titles) > 1:
        assert titles[0] == "Use JWT for authentication"


@pytest.mark.asyncio
async def test_get_context_decision_titles_for_governed_file(setup_mcp_decisions):
    """A file governed by a decision link surfaces its title under include=["decisions"]."""
    from repowise.server.mcp_server import get_context

    result = await get_context(["src/db/models.py"], include=["decisions"])
    t = result["targets"]["src/db/models.py"]

    # dec_db governs src/db/models.py via DecisionNodeLink — titles must be present.
    assert t.get("decision_records")


@pytest.mark.asyncio
async def test_get_context_decision_titles_capped_at_three(setup_mcp_decisions, session):
    """decision_records titles are capped at 3 entries."""
    from repowise.server.mcp_server import get_context

    rid = "repo1"
    # Add 4 more decisions + links to push total > 5 for src/auth/service.py
    for i in range(4):
        d = DecisionRecord(
            repository_id=rid,
            title=f"Extra decision {i}",
            status="active",
            context="extra",
            # Its own body: identity is the evidence, so four records sharing
            # one body over one file would be one decision.
            decision=f"extra {i}",
            rationale="extra",
            alternatives_json="[]",
            consequences_json="[]",
            affected_files_json=json.dumps(["src/auth/service.py"]),
            affected_modules_json="[]",
            tags_json="[]",
            source="git_archaeology",
            confidence=0.3,
            staleness_score=0.0,
            verification="unverified",
            created_at=_NOW,
            updated_at=_NOW,
        )
        session.add(d)
        await session.flush()
        lnk = DecisionNodeLink(
            repository_id=rid,
            decision_id=d.id,
            node_id="src/auth/service.py",
            link_type="file",
            created_at=_NOW,
        )
        session.add(lnk)
    await session.flush()

    result = await get_context(["src/auth/service.py"], include=["decisions"])
    t = result["targets"]["src/auth/service.py"]
    titles = t.get("decision_records", [])
    assert len(titles) <= 3, f"decision_records should be capped at 3, got {len(titles)}"


# ---------------------------------------------------------------------------
# Task 2: get_risk — directive.governance_risk in PR mode
# ---------------------------------------------------------------------------


@pytest.mark.asyncio
async def test_get_risk_pr_mode_governance_risk_present(setup_mcp_decisions):
    """PR mode includes governance_risk in directive."""
    from repowise.server.mcp_server import get_risk

    result = await get_risk(
        ["src/auth/service.py"],
        changed_files=["src/auth/service.py"],
    )
    assert "directive" in result
    directive = result["directive"]

    # governance_risk field must exist
    assert "governance_risk" in directive
    gr = directive["governance_risk"]
    assert isinstance(gr, list)

    # dec_stale is active + staleness_score=0.8 → should appear as stale_governance
    stale_entries = [e for e in gr if e.get("decision_id") == "dec_stale"]
    assert stale_entries, f"Expected dec_stale in governance_risk, got {gr}"
    assert stale_entries[0]["reason"] == "stale_governance"
    assert stale_entries[0]["file"] == "src/auth/service.py"
    assert "title" in stale_entries[0]
    assert "status" in stale_entries[0]

    # dec_superseded should appear as superseded_decision
    sup_entries = [e for e in gr if e.get("decision_id") == "dec_superseded"]
    assert sup_entries, f"Expected dec_superseded in governance_risk, got {gr}"
    assert sup_entries[0]["reason"] == "superseded_decision"


@pytest.mark.asyncio
async def test_get_risk_pr_mode_governance_risk_summary_mentions_count(setup_mcp_decisions):
    """Summary string mentions governance risk count when > 0."""
    from repowise.server.mcp_server import get_risk

    result = await get_risk(
        ["src/auth/service.py"],
        changed_files=["src/auth/service.py"],
    )
    directive = result["directive"]
    gov_count = len(directive.get("governance_risk", []))
    if gov_count > 0:
        assert str(gov_count) in directive["summary"] or "governance" in directive["summary"].lower()


@pytest.mark.asyncio
async def test_get_risk_pr_mode_governance_risk_capped(setup_mcp_decisions):
    """governance_risk is capped at ~5 entries."""
    from repowise.server.mcp_server import get_risk

    result = await get_risk(
        ["src/auth/service.py"],
        changed_files=["src/auth/service.py"],
    )
    gr = result["directive"].get("governance_risk", [])
    assert len(gr) <= 5


@pytest.mark.asyncio
async def test_get_risk_no_changed_files_no_governance_risk(setup_mcp_decisions):
    """Without changed_files (non-PR mode), directive is absent and no governance_risk."""
    from repowise.server.mcp_server import get_risk

    result = await get_risk(["src/auth/service.py", "src/db/models.py"])
    # No directive in standard mode
    assert "directive" not in result
    assert "global_hotspots" in result


@pytest.mark.asyncio
async def test_get_risk_pr_mode_no_governance_risk_for_clean_file(setup_mcp_decisions):
    """Files governed only by healthy decisions produce an empty governance_risk."""
    from repowise.server.mcp_server import get_risk

    # src/db/models.py is governed by dec_db (active, staleness=0.0) only
    result = await get_risk(
        ["src/db/models.py"],
        changed_files=["src/db/models.py"],
    )
    directive = result["directive"]
    assert "governance_risk" in directive
    # dec_db is active with staleness=0.0, not superseded, not conflicted directly
    # dec_stale conflicts with dec_db — so dec_db IS in conflict_decision_ids.
    # dec_db governed nodes include src/db/models.py. So it may appear as "contradicted_decision".
    # This is correct behavior — we don't assert empty here, just that it's a list.
    gr = directive["governance_risk"]
    assert isinstance(gr, list)


# ---------------------------------------------------------------------------
# Task 3: get_overview — key_decisions section
# ---------------------------------------------------------------------------


@pytest.mark.asyncio
async def test_get_overview_key_decisions_present(setup_mcp_decisions):
    """get_overview returns key_decisions when active decisions exist."""
    from repowise.server.mcp_server import get_overview

    assert "key_decisions" not in await get_overview(), "key_decisions is opt-in"
    result = await get_overview(include=["decisions"])
    assert "key_decisions" in result, "key_decisions should appear when active decisions exist"

    kd = result["key_decisions"]
    assert "top_active" in kd
    top = kd["top_active"]
    assert isinstance(top, list)
    assert len(top) >= 1

    # Check dict shape
    for entry in top:
        assert "id" in entry
        assert "title" in entry
        assert "status" in entry
        assert "confidence" in entry
        assert "verification" in entry
        assert "affected_files" in entry
        assert isinstance(entry["affected_files"], list)
        assert len(entry["affected_files"]) <= 3

    # Only active decisions should appear
    for entry in top:
        assert entry["status"] == "active"


@pytest.mark.asyncio
async def test_get_overview_key_decisions_sorted_by_confidence(setup_mcp_decisions):
    """top_active is sorted by confidence descending."""
    from repowise.server.mcp_server import get_overview

    result = await get_overview(include=["decisions"])
    top = result["key_decisions"]["top_active"]
    if len(top) > 1:
        confidences = [e["confidence"] for e in top]
        for i in range(len(confidences) - 1):
            assert confidences[i] >= confidences[i + 1], (
                f"top_active not sorted by confidence desc at index {i}"
            )


@pytest.mark.asyncio
async def test_get_overview_recent_reversals(setup_mcp_decisions):
    """recent_reversals lists supersedes edges with src/dst titles."""
    from repowise.server.mcp_server import get_overview

    result = await get_overview(include=["decisions"])
    kd = result["key_decisions"]
    assert "recent_reversals" in kd
    reversals = kd["recent_reversals"]
    assert isinstance(reversals, list)

    # We seeded dec_active supersedes dec_superseded
    if reversals:
        rev = reversals[0]
        assert "newer" in rev
        assert "older" in rev
        assert "id" in rev["newer"]
        assert "title" in rev["newer"]
        assert "id" in rev["older"]
        assert "title" in rev["older"]
        assert "status" in rev["older"]

        # Verify the specific reversal we seeded
        titled_reversals = [r for r in reversals if r["newer"]["id"] == "dec_active"]
        assert titled_reversals
        assert titled_reversals[0]["older"]["id"] == "dec_superseded"
        assert titled_reversals[0]["older"]["status"] == "superseded"


@pytest.mark.asyncio
async def test_get_overview_key_decisions_capped_at_five(setup_mcp_decisions):
    """top_active is capped at 5 entries."""
    from repowise.server.mcp_server import get_overview

    result = await get_overview(include=["decisions"])
    top = result["key_decisions"]["top_active"]
    assert len(top) <= 5