Codebase intelligence for AI and humans: code health scores, auto-generated docs, git analytics, dead code detection, and architectural decisions via MCP.
Python aicode-complexitycode-healthcode-intelligencecode-qualitydead-codedeveloper-toolsdocumentationgit-analyticsmcpopen-sourcepythonrefactoringstatic-analysistechnical-debt
"""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