argus-code-review 0.2.6__tar.gz → 0.2.7__tar.gz

{argus_code_review-0.2.6 → argus_code_review-0.2.7}/CHANGELOG.md

@@ -7,6 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.7] - 2026-09-26
+
+### Fixed
+
+- Reworded a misleading log message in `argus/graph.py`'s `_node_lite_review`
+  (TECH-6878, #29). The log previously stated "Lite round history skipped on HTTP
+  storage path", which was misinterpreted as indicating that review persistence
+  was skipped altogether and caused an operator/agent to file a false bug
+  report. The message now clarifies that only the comment markdown section for
+  prior lite history is omitted (because `select_recent_lite_rounds` is not
+  implemented in the HTTP storage shim), while the round's own finalize write is
+  not skipped and is attempted normally.
+- Added test coverage for lite-round persistence round-tripping through both the
+  SQLite and HTTP storage backends (previously untested for HTTP), verifying that
+  `reviewer_version="v3-lite"` is preserved on write and read (TECH-6878, #29).
+  Also marked `test_insert_agent_runs_batch[http]` as an explicit xfail for the
+  documented HTTP shim analytics gap rather than letting it pass vacuously.
+
 ## [0.2.6] - 2026-09-19
 
 ### Fixed
@@ -338,7 +356,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   packaged set.
 - `argus --version`, `argus prompts list`, and `argus prompts export`.
 
-[Unreleased]: https://github.com/redesignhealth/argus-review/compare/v0.2.6...HEAD
+[Unreleased]: https://github.com/redesignhealth/argus-review/compare/v0.2.7...HEAD
+[0.2.7]: https://github.com/redesignhealth/argus-review/compare/v0.2.6...v0.2.7
 [0.2.6]: https://github.com/redesignhealth/argus-review/compare/v0.2.5...v0.2.6
 [0.2.5]: https://github.com/redesignhealth/argus-review/compare/v0.2.4...v0.2.5
 [0.2.4]: https://github.com/redesignhealth/argus-review/compare/v0.2.3...v0.2.4

{argus_code_review-0.2.6 → argus_code_review-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: argus-code-review
-Version: 0.2.6
+Version: 0.2.7
 Summary: Self-orchestrated PR review agent using LangGraph + Claude Agent SDK
 Project-URL: Repository, https://github.com/redesignhealth/argus-review
 Project-URL: Issues, https://github.com/redesignhealth/argus-review/issues

{argus_code_review-0.2.6 → argus_code_review-0.2.7}/argus/graph.py

@@ -2228,7 +2228,11 @@ async def _node_lite_review(state: ReviewState) -> dict[str, Any]:
         except Exception:  # noqa: BLE001
             logger.error("Failed to build lite round history — skipping section", exc_info=True)
     elif req.pr_number and _lite_history_backend_kind == "http":
-        logger.info("Lite round history skipped on HTTP storage path")
+        logger.info(
+            "Lite round history markdown section omitted on HTTP storage path "
+            "(select_recent_lite_rounds not implemented in HTTP shim; "
+            "the round's own finalize write is not skipped and will be attempted normally)"
+        )
 
     response.review_comment = (
         f"## Code Review — Round {round_num} (Lite Mode)\n\n"

{argus_code_review-0.2.6 → argus_code_review-0.2.7}/tests/storage/test_backend_contract.py

@@ -3,22 +3,20 @@
 Every scenario in this file exercises the seven logical operations defined
 by ``argus/storage/sql.py`` (the Postgres canonical writer) purely through
 their Pydantic input/output shapes — no backend-specific assertions. The
-goal is a single suite that can run, unmodified, against any backend that
-implements the same operations: today that's just
-:class:`argus.storage.sqlite.SqliteHistoryBackend` (wired via the
-``backend`` fixture below); ``postgres`` and ``http`` params are declared
-already (each ``pytest.mark.skip``ped with the reason it isn't wired yet)
-so that adding those fixtures later is a matter of filling in the
-``elif`` branch in ``backend()`` — no test bodies change.
-
+goal is a single suite that runs against any backend implementing the same
+operations:
+
+- **sqlite**: fully supported locally (:class:`argus.storage.sqlite.SqliteHistoryBackend`).
+- **http**: wired via ``pytest-httpx`` standing in for the two-endpoint HTTP
+  storage contract (see ``docs/STORAGE.md``). Operations not implemented by
+  the minimal HTTP shim (e.g. status polling, recent-rounds listing,
+  select_recent_lite_rounds, insert_agent_runs) are documented and marked xfail.
+  Completed-round persistence and latest-round reads (including for lite-mode
+  reviews) are fully supported and verified.
 - **postgres**: needs a live database and ``argus.storage.session`` wired
-  up. Guard with ``ARGUS_DB_URL`` / ``SUPABASE_DB_URL`` env-var presence and
-  the ``integration`` marker once wired, mirroring the pattern in
+  up. Guarded with ``ARGUS_DB_URL`` / ``SUPABASE_DB_URL`` env-var presence and
+  the ``integration`` marker, mirroring the pattern in
   ``tests/storage/test_sql.py``.
-- **http**: needs a ``pytest-httpx`` fixture standing in for your configured
-  HTTP backend's endpoints (see ``docs/STORAGE.md`` for the contract). Once
-  wired, ``HttpStorageClient`` would sit behind the same seven-operation
-  surface as a thin adapter.
 
 Scenario coverage:
 
@@ -103,6 +101,9 @@ _HTTP_UNSUPPORTED_TESTS = {
     # select_recent_rounds -- not exposed over HTTP.
     "test_select_recent_rounds_orders_desc_and_respects_limit",
     "test_repeated_running_upsert_same_flow_run_id_does_not_duplicate",
+    # insert_agent_runs -- documented no-op on HTTP path (analytics inserts
+    # not covered by minimal HTTP shim, TECH-3487 follow-up).
+    "test_insert_agent_runs_batch",
     # select_recent_lite_rounds -- documented no-op (always returns []).
     "test_select_recent_lite_rounds_filters_reviewer_version",
     "test_select_recent_lite_rounds_default_limit_is_200",
@@ -112,6 +113,14 @@ _HTTP_UNSUPPORTED_TESTS = {
 def _mark_known_http_gaps(request: pytest.FixtureRequest) -> None:
     base_name = request.node.name.split("[")[0]
     if base_name in _HTTP_UNSUPPORTED_TESTS:
+        # insert_agent_runs is a documented no-op on the HTTP shim (analytics
+        # inserts not covered, TECH-3487 follow-up); the call does not assert
+        # rows or raise, so xfail directly rather than letting it pass vacuously.
+        if base_name == "test_insert_agent_runs_batch":
+            pytest.xfail(
+                "HTTP storage shim does not support agent_runs analytics inserts "
+                "(documented Phase-1 gap, TECH-3487)"
+            )
         request.node.add_marker(
             pytest.mark.xfail(
                 reason=(
@@ -202,10 +211,10 @@ async def backend(
         return
 
     if backend_kind == "http":
+        _mark_known_http_gaps(request)
         httpx_mock = request.getfixturevalue("httpx_mock")
         httpx_mock.add_callback(_FakeHttpStorageBackend().handle, is_reusable=True)
         install_http_storage(read_url=_HTTP_READ_URL, write_url=_HTTP_WRITE_URL)
-        _mark_known_http_gaps(request)
         try:
             yield HttpHistoryBackend()
         finally:
@@ -317,6 +326,79 @@ async def test_upsert_completed_row_defaults_reviewer_version_and_stage(
     assert written.verdict is None
 
 
+async def test_lite_round_completed_upsert_round_trips_through_latest(
+    backend: HistoryBackend,
+) -> None:
+    """Lite-mode rounds (reviewer_version='v3-lite') must persist via
+    upsert_completed_row and round-trip through select_latest_completed_round
+    on all backends (including the HTTP storage shim).
+    """
+    payload = CodeReviewRoundIn(
+        flow_run_id="fr-lite-rt-1",
+        repo="org/repo-lite",
+        pr_number=10,
+        verdict="approve",
+        risk_level="low",
+        blocking_count=0,
+        suggestion_count=0,
+        review_comment="lgtm lite review",
+        reviewer_version="v3-lite",
+        result_json={"review_round": 2, "preflight_reason": "test-only diff"},
+        sha="deadbeef123",
+        base_ref="main",
+    )
+
+    written = await backend.upsert_completed_row(row=payload)
+    assert written.reviewer_version == "v3-lite"
+
+    latest = await backend.select_latest_completed_round(repo="org/repo-lite", pr_number=10)
+    assert latest is not None
+    assert latest.id == written.id
+    assert latest.reviewer_version == "v3-lite"
+    assert latest.verdict == "approve"
+    assert latest.sha == "deadbeef123"
+    assert latest.result_json == {"review_round": 2, "preflight_reason": "test-only diff"}
+    assert latest.prior_count == 1
+
+
+async def test_lite_round_becomes_latest_completed_round(
+    backend: HistoryBackend,
+) -> None:
+    """When a lite review follows a full review on the same PR, the lite
+    round becomes the latest completed round and preserves its version.
+    """
+    first_full = await backend.upsert_completed_row(
+        row=CodeReviewRoundIn(
+            flow_run_id="fr-seq-1",
+            repo="org/repo-seq",
+            pr_number=20,
+            verdict="block",
+            reviewer_version="v3",
+            sha="sha-round-1",
+        )
+    )
+    second_lite = await backend.upsert_completed_row(
+        row=CodeReviewRoundIn(
+            flow_run_id="fr-seq-2",
+            repo="org/repo-seq",
+            pr_number=20,
+            verdict="approve",
+            reviewer_version="v3-lite",
+            sha="sha-round-2",
+            result_json={"review_round": 2, "preflight_reason": "catchup on green CI"},
+        )
+    )
+
+    latest = await backend.select_latest_completed_round(repo="org/repo-seq", pr_number=20)
+    assert latest is not None
+    assert latest.id == second_lite.id
+    assert latest.id != first_full.id
+    assert latest.reviewer_version == "v3-lite"
+    assert latest.verdict == "approve"
+    assert latest.sha == "sha-round-2"
+    assert latest.prior_count == 2
+
+
 # ---------------------------------------------------------------------------
 # 3. Two completed rounds -> latest wins; select_recent_rounds ordering + limit
 # ---------------------------------------------------------------------------
@@ -471,7 +553,7 @@ async def test_completed_upsert_same_flow_run_id_preserves_sha_via_coalesce(
 # ---------------------------------------------------------------------------
 
 
-async def test_insert_agent_runs_batch(backend: SqliteHistoryBackend) -> None:
+async def test_insert_agent_runs_batch(backend: HistoryBackend) -> None:
     review = await backend.upsert_completed_row(
         row=CodeReviewRoundIn(repo="org/repo6", pr_number=2, verdict="approve")
     )

{argus_code_review-0.2.6 → argus_code_review-0.2.7}/tests/storage/test_http.py

@@ -11,6 +11,7 @@ Tests use ``pytest-httpx`` to mock the backend side; no real network.
 
 from __future__ import annotations
 
+import json
 from datetime import UTC, datetime
 from uuid import uuid4
 
@@ -249,3 +250,70 @@ def test_install_raises_on_conflicting_reinstall() -> None:
     install_http_storage(read_url=_READ_URL, write_url=_WRITE_URL, auth="ApiKey k")
     with pytest.raises(HttpStorageError, match="different parameters"):
         install_http_storage(read_url=_READ_URL, write_url=_WRITE_URL, auth="ApiKey DIFFERENT")
+
+
+@pytest.mark.asyncio
+async def test_write_and_read_lite_round_round_trip(httpx_mock: HTTPXMock) -> None:
+    """A lite-mode round (reviewer_version="v3-lite") written via
+    HttpStorageClient.write_round round-trips through
+    read_latest_completed_round with reviewer_version preserved.
+    """
+    written_id = uuid4()
+    round_payload = _row_payload(
+        id=str(written_id),
+        reviewer_version="v3-lite",
+        verdict="APPROVE",
+        sha="131e334046bf",
+        result_json={"review_round": 8, "preflight_reason": "test-only diff"},
+    )
+    httpx_mock.add_response(
+        method="POST",
+        url="https://fake-storage-backend.test/api/v1/code-review/storage/reviews/acme/example-repo/158/rounds",
+        status_code=201,
+        json=round_payload,
+    )
+    httpx_mock.add_response(
+        method="GET",
+        url="https://fake-storage-backend.test/api/v1/code-review/storage/reviews/acme/example-repo/158",
+        status_code=200,
+        json={"rounds": [round_payload]},
+    )
+
+    client = HttpStorageClient(read_url=_READ_URL, write_url=_WRITE_URL, auth="ApiKey test")
+    try:
+        round_data = CodeReviewRound(
+            repo="acme/example-repo",
+            pr_number=158,
+            verdict="APPROVE",
+            risk_level="LOW",
+            blocking_count=0,
+            suggestion_count=0,
+            reviewer_version="v3-lite",
+            sha="131e334046bf",
+            result_json={"review_round": 8, "preflight_reason": "test-only diff"},
+        )
+        written = await client.write_round(
+            owner="acme", repo="example-repo", pr=158, round_data=round_data
+        )
+        assert written.id == written_id
+        assert written.reviewer_version == "v3-lite"
+
+        # Verify POST payload sent the reviewer_version
+        post_request = httpx_mock.get_requests()[0]
+        assert post_request.method == "POST"
+        posted_body = json.loads(post_request.content)
+        assert posted_body["reviewer_version"] == "v3-lite"
+        assert posted_body["sha"] == "131e334046bf"
+
+        latest, count = await client.read_latest_completed_round(
+            owner="acme", repo="example-repo", pr=158
+        )
+        assert latest is not None
+        assert latest.id == written_id
+        assert latest.reviewer_version == "v3-lite"
+        assert latest.verdict == "APPROVE"
+        assert latest.sha == "131e334046bf"
+        assert latest.result_json == {"review_round": 8, "preflight_reason": "test-only diff"}
+        assert count == 1
+    finally:
+        await client.aclose()