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.

28.3 KB
Raw Blame
"""`repowise report changes`: the period pass, each change's answers, the
policy verdict, the summary, the renderers and the CLI, over a fixture index."""

from __future__ import annotations

import csv
import io
import json
from datetime import UTC, datetime
from pathlib import Path

import pytest
from click.testing import CliRunner

from repowise.core.changes.evidence import ChangeEvidence, EvidenceItem

HEAD1, HEAD2, HEAD3 = "a" * 40, "b" * 40, "e" * 40
SINCE, UNTIL = datetime(2026, 2, 1, tzinfo=UTC), datetime(2026, 4, 1, tzinfo=UTC)

POLICY = """
rules:
  - name: pci-needs-tests
    match: {components: {tags: [pci]}}
    when: {reaching_tests: missing}
    action: fail
  - name: agent-review
    when: {attribution: agent}
    action: require_owner_review
  - name: scan
    gate: security
"""


def _change(cid: str, number: str, head: str, title: str, merged: datetime, category: str) -> dict:
    return {
        "change_id": cid,
        "identity_kind": "pr",
        "identity_value": number,
        "shape": "squash",
        "forge": "github",
        "forge_ref": f"#{number}",
        "title": title,
        "merged_at": merged,
        "head_sha": head,
        "commit_shas_json": json.dumps([head]),
        "files_json": json.dumps([{"path": "pay/a.py", "added": 3, "deleted": 1}]),
        "files_changed": 1,
        "lines_added": 3,
        "lines_deleted": 1,
        "category": category,
        "metadata_source": "git",
        "author_name": "Alice Example",
        "author_email": "[email protected]",
    }


async def _seed(root: Path) -> None:
    from repowise.core.persistence import (
        create_engine,
        create_session_factory,
        get_session,
        init_db,
        upsert_repository,
    )
    from repowise.core.persistence.crud import upsert_changes
    from repowise.core.persistence.models import GitCommit

    (root / ".git").mkdir(parents=True, exist_ok=True)
    (root / ".repowise").mkdir(exist_ok=True)
    engine = create_engine(f"sqlite+aiosqlite:///{(root / '.repowise' / 'wiki.db').as_posix()}")
    try:
        await init_db(engine)
        async with get_session(create_session_factory(engine)) as session:
            repo = await upsert_repository(session, name="shop", local_path=str(root))
            await upsert_changes(
                session,
                repo.id,
                [
                    _change("pr-1", "1", HEAD1, '=HYPERLINK("http://x") fix', datetime(2026, 3, 1, tzinfo=UTC), "fix"),
                    _change("pr-2", "2", HEAD2, "feat: refunds", datetime(2026, 3, 5, tzinfo=UTC), "feature"),
                    _change("pr-3", "3", HEAD3, "fix: later", datetime(2026, 4, 2, tzinfo=UTC), "fix"),
                ],
            )
            session.add(
                GitCommit(
                    repository_id=repo.id,
                    sha=HEAD1,
                    author_name="Alice Example",
                    author_email="[email protected]",
                    committed_at=datetime(2026, 3, 1, tzinfo=UTC),
                    attribution="agent",
                    agent_name="claude",
                    agent_model_id="anthropic/claude-x",
                )
            )
    finally:
        await engine.dispose()


def _gone(kind: str, label: str, reason: str) -> EvidenceItem:
    return EvidenceItem(kind, label, "unknown", "unresolved", None, [{"reason": reason}], "test")


def _evidence(change_id: str) -> ChangeEvidence:
    """pr-1 answers everything; any other change answers nothing."""
    if change_id != "pr-1":
        items = [
            _gone("components_touched", "Components touched", "no component holds the changed files"),
            _gone("owners", "Declared owners", "the repository declares no owners"),
            _gone("reaching_tests", "Tests reaching the change", "no test map"),
            _gone("provenance", "AI provenance", "no attribution was stored"),
            _gone("outcomes", "Outcomes since merge", "a shallow clone cuts off the history"),
        ]
    else:
        items = [
            EvidenceItem(
                "components_touched", "Components touched", "ok", "declared", ["payments"],
                [{"name": "payments", "source": "declared", "owner": "payments-team",
                  "criticality": "high", "tags": ["pci"], "files": ["pay/a.py"], "bus_factor": 1}],
                "components",
            ),
            EvidenceItem(
                "owners", "Declared owners", "ok", "declared", ["@acme/payments-team", "@alice"],
                [{"owner": "@acme/payments-team", "paths": ["pay/a.py"]},
                 {"owner": "@alice", "paths": ["pay/a.py"]}],
                "CODEOWNERS",
            ),
            EvidenceItem(
                "suggested_reviewers", "Suggested reviewers", "ok", "inferred", ["Bob Person"],
                [{"name": "Bob Person", "paths": ["pay/a.py"], "reasons": ["co-change"]}],
                "git history",
            ),
            EvidenceItem(
                "reaching_tests", "Tests reaching the change", "attention", "measured",
                {"measured": 0, "inferred": 0, "files_without_tests": 1, "files_unknown": 0},
                [{"path": "pay/a.py", "tests": [], "measured": True}],
                "test impact",
            ),
            EvidenceItem(
                "provenance", "AI provenance", "ok", "measured",
                {"label": "agent", "agent_commits": 1, "human_attested_commits": 0,
                 "unknown_commits": 0, "coverage": 1.0},
                [{"sha": HEAD1, "label": "agent", "tier": 2}],
                "attribution",
            ),
            EvidenceItem(
                "outcomes", "Outcomes since merge", "attention", "declared",
                {"reverted": True, "reverts": 1, "fix_references": 0, "as_of": "", "days": 30},
                [{"kind": "revert", "sha": "d" * 40, "change_id": "pr-9", "in_force": True,
                  "evidence": 'Revert "fix"'}],
                "git history",
            ),
        ]
    return ChangeEvidence(change_id, None, "2026-10-14T00:00:00+00:00", items, index_commit="c" * 40)


@pytest.fixture
def builds(monkeypatch: pytest.MonkeyPatch) -> list[str]:
    """Stand in for the review; these tests are about the pack, not the checklist."""
    from repowise.core.changes import collect

    calls: list[str] = []

    async def build(session, repo_id, root, row, **_k):
        calls.append(row.change_id)
        return _evidence(row.change_id)

    monkeypatch.setattr(collect, "build_stored_evidence", build)
    return calls


@pytest.fixture
def root(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
    from repowise.cli.helpers import run_async

    monkeypatch.delenv("REPOWISE_DB_URL", raising=False)
    monkeypatch.delenv("REPOWISE_DATABASE_URL", raising=False)
    root = (tmp_path / "shop").resolve()
    run_async(_seed(root))
    return root


@pytest.fixture
async def ctx(root: Path):
    from repowise.core.changes.period import PeriodRequest
    from repowise.core.persistence import create_engine, create_session_factory, get_session
    from repowise.core.persistence.models import Repository
    from repowise.core.report.model import ReportContext

    engine = create_engine(f"sqlite+aiosqlite:///{(root / '.repowise' / 'wiki.db').as_posix()}")
    async with get_session(create_session_factory(engine)) as session:
        repo = (await session.execute(Repository.__table__.select())).first()
        yield ReportContext(session, repo.id, root, period=PeriodRequest(since=SINCE, until=UNTIL))
    await engine.dispose()


def _over(ctx, **options):
    """The period pass over the fixture window, with *options* on its request."""
    from repowise.core.changes.period import PeriodRequest, period_evidence

    request = PeriodRequest(since=SINCE, until=UNTIL, **options)
    return period_evidence(ctx.session, ctx.repository_id, ctx.repo_root, request)


async def _document(ctx) -> dict:
    from repowise.core.report.build import assemble, available_sections, collect_repo

    sections = available_sections("changes")
    doc = assemble({"kind": "repo", "name": "shop"}, [await collect_repo(ctx, sections)])
    doc["kind"] = "changes"
    return doc


def _section(doc: dict, sid: str) -> dict[str, dict]:
    (section,) = [s for s in doc["sections"] if s["id"] == sid]
    return {c["name"]: c for c in section["checks"]}


# -- the period pass ----------------------------------------------------------


async def test_period_builds_missing_checklists_once_and_keeps_them(ctx, builds):
    from repowise.core.changes.collect import cached_evidence
    from repowise.core.persistence.crud import get_change

    seen: list[tuple[int, int, str]] = []
    first = [
        r.change_id
        async for r, _e in _over(ctx, progress=lambda *a: seen.append(a),
        )
    ]
    assert first == ["pr-2", "pr-1"] and sorted(builds) == ["pr-1", "pr-2"]
    assert sorted(seen) == [(1, 2, "pr-2"), (2, 2, "pr-1")]
    kept = cached_evidence(await get_change(ctx.session, ctx.repository_id, "pr-1"))
    assert kept is not None and kept.item("outcomes") is not None

    builds.clear()
    again = [r.change_id async for r, _e in _over(ctx)]
    assert again == ["pr-2", "pr-1"] and builds == []

    _ = [r async for r in _over(ctx, refresh=True)]
    assert sorted(builds) == ["pr-1", "pr-2"]


# -- one change ---------------------------------------------------------------


def _entry(change_id: str, policy=None, policy_error=None, attribution=True) -> dict:
    from repowise.core.ownership.directory import DeclaredOwnership
    from repowise.core.report.change_answers import EntryContext, entry

    record = {
        "id": change_id, "forge_ref": "#1", "title": "t", "merged_at": "2026-03-01T00:00:00+00:00",
        "category": "fix", "head_sha": HEAD1, "commits": [HEAD1], "files_changed": 1,
        "lines_added": 3, "lines_deleted": 1,
        "metadata": {"source": "git", "reviewers": None, "approvals": None},
    }
    context = EntryContext(
        policy=policy, policy_error=policy_error,
        declared=DeclaredOwnership(codeowners_file=".github/CODEOWNERS"),
        agents={HEAD1: ("claude", "anthropic/claude-x")}, attribution=attribution,
    )
    return entry(record, _evidence(change_id).to_dict(), context)


def test_a_change_names_teams_and_counts_people():
    e = _entry("pr-1")
    assert e["accountable"]["teams"] == ["payments-team"]
    assert e["accountable"]["individual_owners"] == 1
    assert e["provenance"]["agents"] == ["claude"] and e["provenance"]["models"] == ["anthropic/claude-x"]
    assert e["outcome"]["reverted"] is True and "reverted by pr-9" in e["outcome"]["text"]
    assert e["tests"]["files_without_tests"] == 1 and e["complete"] is True
    text = json.dumps(e)
    for person in ("alice", "Alice", "Bob Person"):
        assert person not in text


def test_review_is_not_recorded_in_git_never_missing():
    from repowise.core.report.change_answers import review as _review

    e = _entry("pr-1")
    assert e["review"] == {
        "status": "unknown", "basis": "unresolved", "source": "git", "text": "not recorded in git",
    }
    trailers = _review({"source": "git", "approvals": 2, "reviewers": None})
    assert trailers["status"] == "known" and "Approved-by" in trailers["text"]
    forge = _review({"source": "acme-forge", "approvals": None, "reviewers": ["ana", "li"]})
    assert forge["reviewers"] == 2 and "ana" not in json.dumps(forge)


def test_unknown_evidence_stays_unknown_never_negative():
    from repowise.core.policy import parse_policy

    e = _entry("pr-2", policy=parse_policy(POLICY))
    for key in ("accountable", "tests", "outcome", "provenance", "review"):
        assert e[key]["status"] == "unknown", key
    assert e["policy"]["verdict"] == "unknown" and e["complete"] is False
    assert "reverted" not in e["outcome"] and e["provenance"]["commits"] == 1
    assert "not recorded" in e["review"]["text"]


def test_policy_evaluates_condition_rules_and_never_reruns_gates():
    from repowise.core.policy import parse_policy
    from repowise.core.report.change_answers import policy_verdict

    policy = parse_policy(POLICY)
    verdict = _entry("pr-1", policy=policy)["policy"]
    assert verdict["verdict"] == "fail" and verdict["gates_not_rerun"] == ["scan"]
    fired = {r["rule"]: r["outcome"] for r in verdict["rules"]}
    assert fired == {"pci-needs-tests": "triggered", "agent-review": "triggered"}
    assert policy_verdict(None, None, {})["verdict"] == "none"
    assert policy_verdict(None, "bad file", {})["verdict"] == "unknown"
    gates_only = parse_policy("rules:\n  - name: scan\n    gate: security\n")
    assert policy_verdict(gates_only, None, {})["verdict"] == "unknown"
    warn = parse_policy("rules:\n  - name: agent-review\n    when: {attribution: agent}\n    action: warn\n")
    assert _entry("pr-1", policy=warn)["policy"]["verdict"] == "warn"


# -- the report ---------------------------------------------------------------


async def test_summary_counts_the_period_by_change_and_component(ctx, builds):
    (ctx.repo_root / ".repowise" / "policies.yaml").write_text(POLICY, encoding="utf-8")
    doc = await _document(ctx)
    assert [s["id"] for s in doc["sections"]] == ["change-summary", "changes", "change-method"]
    summary = _section(doc, "change-summary")
    assert summary["changes-in-period"]["data"]["changes"] == 2
    assert summary["checklists"]["data"]["complete"] == 1
    assert summary["review-records"]["basis"] == "unresolved"
    assert summary["policy"]["data"] == {
        "configured": True, "source": ".repowise/policies.yaml",
        "pass": 0, "warn": 0, "fail": 1, "unknown": 1,
    }
    assert summary["outcomes"]["data"]["reverted"] == ["#1"]
    assert summary["components"]["data"]["components"] == {
        "payments": {"changes": 1, "teams": ["payments-team"]}
    }
    # Coverage and names, never a count or share of agent work.
    assert summary["provenance"]["data"] == {
        "commits": 2, "known": 1, "agents": ["claude"], "models": ["anthropic/claude-x"],
    }
    changes = _section(doc, "changes")
    assert set(changes) == {"#1", "#2"}
    assert changes["#2"]["basis"] == "unresolved" and changes["#2"]["score"] == -1
    assert changes["#1"]["basis"] == "measured"


async def test_no_policy_file_reads_no_policy_configured(ctx, builds):
    doc = await _document(ctx)
    assert "no policy configured" in _section(doc, "change-summary")["policy"]["reason"]
    assert all(
        c["data"]["change"]["policy"]["verdict"] == "none" for c in _section(doc, "changes").values()
    )


async def test_method_appendix_says_what_git_cannot_attest(ctx, builds):
    method = _section(await _document(ctx), "change-method")
    assert {"period", "review", "tests", "policy", "accountability", "provenance", "outcomes",
            "snapshot", "not-attested"} == set(method)
    assert "the start --since gave" in method["period"]["reason"]
    assert "not recorded in" in method["review"]["reason"]
    assert method["not-attested"]["basis"] == "unresolved"


async def test_renderers_present_the_same_pack(ctx, builds):
    from repowise.core.report.render import report_renderers

    doc = await _document(ctx)
    page = report_renderers.get("html")(doc)
    assert page.startswith("<!doctype html>") and "default-src 'none'" in page
    assert "<script" not in page and "Method and basis" in page and "not recorded in git" in page
    assert "Changes: shop" in report_renderers.get("markdown")(doc)

    rows = list(csv.DictReader(io.StringIO(report_renderers.get("csv")(doc))))
    by_check = {r["check"]: r for r in rows}
    assert by_check["#1"]["review"] == "not recorded in git"
    assert by_check["#1"]["teams"] == "payments-team"
    # A commit message that opens as a formula is quoted.
    assert by_check["#1"]["title"].startswith("'=HYPERLINK")
    assert by_check["#1"]["reason"].startswith("2026-03-01")
    assert by_check["changes-in-period"]["review"] == ""


def test_spreadsheet_cells_quote_every_formula_lead():
    from repowise.core.report.render import spreadsheet_cell

    for lead in ("=", "+", "-", "@", "\t", "\r"):
        assert spreadsheet_cell(f"{lead}x") == f"'{lead}x"
    assert spreadsheet_cell("fix: x") == "fix: x" and spreadsheet_cell(None) == ""


# -- CLI ------------------------------------------------------------------------


def test_cli_writes_the_pack_and_reports_progress(root: Path, builds, tmp_path: Path) -> None:
    from repowise.cli.main import cli

    out = tmp_path / "pack.json"
    runner = CliRunner(mix_stderr=False)
    result = runner.invoke(
        cli,
        ["report", "changes", str(root), "--no-workspace", "--since", "2026-02-01",
         "--until", "2026-04-01", "--format", "json", "--out", str(out)],
    )
    assert result.exit_code == 0, result.output
    assert "evidence 1/2: pr-2" in result.stderr
    doc = json.loads(out.read_text(encoding="utf-8"))
    assert doc["kind"] == "changes" and doc["schema_version"] == 1
    assert doc["scope"]["period"] == {"since": "2026-02-01T00:00:00+00:00",
                                      "until": "2026-04-01T00:00:00+00:00"}
    assert str(root) not in out.read_text(encoding="utf-8")

    as_csv = runner.invoke(cli, ["report", "changes", str(root), "--no-workspace", "--format", "csv"])
    assert as_csv.exit_code == 0 and as_csv.stdout.startswith("section,repo,check,score,basis")
    assert builds.count("pr-3") == 1  # the open period took the third change too

    bad = runner.invoke(
        cli, ["report", "changes", str(root), "--no-workspace", "--since", "2026-04-01",
              "--until", "2026-02-01"],
    )
    assert bad.exit_code != 0 and "--since must be before --until" in bad.output + bad.stderr


# -- the default period ----------------------------------------------------------

#: Merged more than 90 days before the newest indexed commit (HEAD1, 2026-03-01).
OLD = _change("pr-0", "0", "f" * 40, "fix: old", datetime(2025, 11, 1, tzinfo=UTC), "fix")


async def test_no_since_covers_90_days_before_the_newest_commit(ctx, builds):
    from dataclasses import replace

    from repowise.core.changes.period import DEFAULT_WINDOW_DAYS, PeriodRequest, period_evidence

    await _add_changes(ctx.repo_root, [OLD])
    request = await PeriodRequest().resolved(ctx.session, ctx.repository_id)
    assert DEFAULT_WINDOW_DAYS == 90 and request.window_days == 90
    assert request.since == datetime(2025, 12, 1, tzinfo=UTC)
    got = [r.change_id async for r, _e in period_evidence(
        ctx.session, ctx.repository_id, ctx.repo_root, PeriodRequest())]
    assert got == ["pr-3", "pr-2", "pr-1"]

    # An earlier --until is the anchor instead of the newest commit.
    until = datetime(2026, 1, 15, tzinfo=UTC)
    early = await PeriodRequest(until=until).resolved(ctx.session, ctx.repository_id)
    assert early.since == datetime(2025, 10, 17, tzinfo=UTC)

    doc = await _document(replace(ctx, period=PeriodRequest()))
    summary = _section(doc, "change-summary")["changes-in-period"]
    assert summary["data"]["window_days"] == 90 and summary["data"]["changes"] == 3
    assert summary["data"]["since"] == "2025-12-01T00:00:00+00:00"
    assert "90 days before 2026-03-01 (the newest indexed commit)" in summary["details"][0]
    method = _section(doc, "change-method")["period"]["reason"]
    assert "from 2025-12-01" in method and "--since all" in method


async def test_explicit_since_wins_and_all_covers_every_change(ctx, builds):
    from repowise.core.changes.period import PeriodRequest, period_evidence

    await _add_changes(ctx.repo_root, [OLD])
    given = await PeriodRequest(since=SINCE).resolved(ctx.session, ctx.repository_id)
    assert given.since == SINCE and given.window_days is None
    every = PeriodRequest(window_days=None)
    assert (await every.resolved(ctx.session, ctx.repository_id)).since is None
    got = [r.change_id async for r, _e in period_evidence(
        ctx.session, ctx.repository_id, ctx.repo_root, every)]
    assert got == ["pr-3", "pr-2", "pr-1", "pr-0"]


def test_cli_defaults_to_the_window_and_takes_since_all(root: Path, builds, tmp_path: Path) -> None:
    from repowise.cli.helpers import run_async
    from repowise.cli.main import cli
    from repowise.core.changes.period import DEFAULT_WINDOW_DAYS

    run_async(_add_changes(root, [OLD]))
    runner = CliRunner(mix_stderr=False)
    out = tmp_path / "pack.json"
    args = ["report", "changes", str(root), "--no-workspace", "--format", "json", "--out", str(out)]

    assert runner.invoke(cli, args).exit_code == 0
    doc = json.loads(out.read_text(encoding="utf-8"))
    assert doc["scope"]["period"] == {"since": None, "until": None, "window_days": 90}
    assert set(_section(doc, "changes")) == {"#1", "#2", "#3"}

    assert runner.invoke(cli, [*args, "--since", "all"]).exit_code == 0
    doc = json.loads(out.read_text(encoding="utf-8"))
    assert doc["scope"]["period"] == {"since": None, "until": None}
    assert set(_section(doc, "changes")) == {"#0", "#1", "#2", "#3"}

    help_text = runner.invoke(cli, ["report", "changes", "--help"]).output
    assert f"{DEFAULT_WINDOW_DAYS} days" in help_text and "`all`" in help_text
    bad = runner.invoke(cli, [*args, "--since", "yesterday"])
    assert bad.exit_code != 0


# -- the pass under load, failure and other writers ---------------------------


async def _add_changes(root: Path, changes: list[dict]) -> None:
    """Write *changes* through an engine of their own, as another process would."""
    from repowise.core.persistence import create_engine, create_session_factory, get_session
    from repowise.core.persistence.crud import get_repository_by_path, upsert_changes

    engine = create_engine(f"sqlite+aiosqlite:///{(root / '.repowise' / 'wiki.db').as_posix()}")
    try:
        async with get_session(create_session_factory(engine)) as session:
            repo = await get_repository_by_path(session, str(root))
            await upsert_changes(session, repo.id, changes)
    finally:
        await engine.dispose()


async def _keep_elsewhere(root: Path, change_id: str, evidence: ChangeEvidence) -> None:
    from repowise.core.changes.collect import save_evidence
    from repowise.core.persistence import create_engine, create_session_factory, get_session
    from repowise.core.persistence.crud import get_repository_by_path

    engine = create_engine(f"sqlite+aiosqlite:///{(root / '.repowise' / 'wiki.db').as_posix()}")
    try:
        async with get_session(create_session_factory(engine)) as session:
            repo = await get_repository_by_path(session, str(root))
            await save_evidence(session, repo.id, change_id, evidence)
    finally:
        await engine.dispose()


def _many(n: int) -> list[dict]:
    return [
        _change(f"pr-{100 + i}", str(100 + i), f"{100 + i:040x}", f"fix: {i}",
                datetime(2026, 3, 10, i % 24, tzinfo=UTC), "fix")
        for i in range(n)
    ]


async def test_many_concurrent_builds_on_disk_are_all_kept(ctx, monkeypatch):
    import asyncio

    from sqlalchemy import func, select

    from repowise.core.changes import collect
    from repowise.core.persistence.models import Change

    await _add_changes(ctx.repo_root, _many(20))
    running = peak = 0

    async def build(session, repo_id, root, row, **_k):
        nonlocal running, peak
        running += 1
        peak = max(peak, running)
        # Each build reads the store on its own session while others write.
        await session.execute(select(func.count()).select_from(Change))
        await asyncio.sleep(0.01)
        running -= 1
        return _evidence(row.change_id)

    monkeypatch.setattr(collect, "build_stored_evidence", build)
    seen = []
    got = [
        r.change_id
        async for r, e in _over(ctx, concurrency=6, progress=lambda *a: seen.append(a),
        )
        if e is not None
    ]
    assert len(got) == 22 and len(set(got)) == 22 and len(seen) == 22 and peak == 6
    kept = await ctx.session.scalar(
        select(func.count()).where(Change.evidence_json.is_not(None))
    )
    assert kept == 22


async def test_a_failed_build_keeps_the_rest_of_its_page(ctx, monkeypatch):
    from repowise.core.changes import collect
    from repowise.core.persistence.crud import list_changes

    async def build(session, repo_id, root, row, **_k):
        if row.change_id == "pr-1":
            raise RuntimeError("parse blew up")
        return _evidence(row.change_id)

    monkeypatch.setattr(collect, "build_stored_evidence", build)
    with pytest.raises(RuntimeError, match="parse blew up"):
        _ = [p async for p in _over(ctx)]
    rows, _ = await list_changes(ctx.session, ctx.repository_id, limit=None)
    kept = {r.change_id for r in rows if r.evidence_json}
    assert kept == {"pr-2"}


async def test_a_checklist_another_writer_kept_is_never_overwritten(ctx, monkeypatch):
    from repowise.core.changes import collect
    from repowise.core.persistence.crud import get_change

    theirs = ChangeEvidence("pr-2", None, "2026-01-01T00:00:00+00:00",
                            [EvidenceItem("owners", "Declared owners", "ok", "declared", [], [], "server")])

    async def build(session, repo_id, root, row, **_k):
        if row.change_id == "pr-2":  # the server kept one while this build ran
            await _keep_elsewhere(root, "pr-2", theirs)
        return _evidence(row.change_id)

    monkeypatch.setattr(collect, "build_stored_evidence", build)
    got = {r.change_id: e async for r, e in _over(ctx)}
    assert got["pr-2"].generated_at == "2026-01-01T00:00:00+00:00"
    ctx.session.expunge_all()
    stored = collect.cached_evidence(await get_change(ctx.session, ctx.repository_id, "pr-2"))
    assert stored.generated_at == "2026-01-01T00:00:00+00:00"


async def test_the_period_is_fixed_before_the_first_build(ctx, monkeypatch):
    from repowise.core.changes import collect, period

    added: list[str] = []

    async def build(session, repo_id, root, row, **_k):
        # A newer change indexed mid-run must not shift the pages or repeat one.
        if not added:
            added.append(row.change_id)
            await _add_changes(root, _many(1))
        return _evidence(row.change_id)

    monkeypatch.setattr(collect, "build_stored_evidence", build)
    monkeypatch.setattr(period, "PAGE", 1)  # a page per change, so a shift would show
    got = [r.change_id async for r, _e in _over(ctx)]
    assert got == ["pr-2", "pr-1"]


def test_no_build_reports_kept_checklists_only(root: Path, builds, tmp_path: Path) -> None:
    from repowise.cli.main import cli

    out = tmp_path / "pack.json"
    runner = CliRunner(mix_stderr=False)
    result = runner.invoke(
        cli,
        ["report", "changes", str(root), "--no-workspace", "--since", "2026-02-01",
         "--until", "2026-04-01", "--format", "json", "--out", str(out), "--no-build"],
    )
    assert result.exit_code == 0, result.output
    assert builds == [] and "building" not in result.stderr
    doc = json.loads(out.read_text(encoding="utf-8"))
    summary = _section(doc, "change-summary")
    assert summary["checklists"]["data"]["not_kept"] == 2
    change = _section(doc, "changes")["#1"]["data"]["change"]
    assert change["tests"]["status"] == "unknown" and "--no-build" in change["tests"]["text"]
    assert change["checklist"]["kept"] is False

    built = runner.invoke(cli, ["report", "changes", str(root), "--no-workspace",
                                "--since", "2026-02-01", "--until", "2026-04-01"])
    assert "building 2 of 2 evidence checklist(s)" in built.stderr
    assert "--no-build" in runner.invoke(cli, ["report", "changes", "--help"]).output


def test_a_newline_in_a_title_survives_the_csv():
    from repowise.core.report.render import render_csv

    doc = {"sections": [{"id": "changes", "repo": None, "checks": [
        {"name": "#1", "score": None, "basis": "measured", "reason": "line one\n=line two",
         "details": ["a"], "data": {"row": {"title": "fix:\nsecond line"}}},
    ]}]}
    (row,) = list(csv.DictReader(io.StringIO(render_csv(doc))))
    assert row["title"] == "fix:\nsecond line" and row["reason"] == "line one\n=line two"


def test_a_change_outside_every_component_is_told_apart_from_an_unknown_one():
    from repowise.core.report.sections.changes import _component_summary

    entries = [
        {"components": [], "components_known": True},
        {"components": [], "components_known": False},
        {"components": [{"name": "payments", "team": None}], "components_known": True},
    ]
    summary = _component_summary(entries)
    assert summary["reason"] == (
        "1 component(s) changed; 1 change(s) outside every component, 1 with components not known"
    )
    assert summary["data"]["outside_every_component"] == 1