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

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

@@ -7,6 +7,36 @@ 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
+
+- Bounded `openai` dependency to `>=1.66.0,<2` in `pyproject.toml` (TECH-6590) to
+  prevent unconstrained fresh installs from resolving to a future breaking major
+  release. The floor was also tightened from `>=1.50.0` to `>=1.66.0` where the
+  OpenAI Responses API (`client.responses.create()`) used by this codebase was
+  introduced. (Note: this is a general hygiene fix; it does not address the root
+  cause of the TECH-6590-reported crash, which was a separate shared-venv version-skew
+  issue tracked in TECH-6592.)
+
 ## [0.2.5] - 2026-09-18
 
 ### Added
@@ -326,7 +356,9 @@ 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.5...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
 [0.2.3]: https://github.com/redesignhealth/argus-review/compare/v0.2.2...v0.2.3

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: argus-code-review
-Version: 0.2.5
+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
@@ -26,7 +26,7 @@ Requires-Dist: langgraph-checkpoint-sqlite>=2.0.0
 Requires-Dist: langgraph<2,>=1.0.10
 Requires-Dist: langsmith<1,>=0.2.0
 Requires-Dist: litellm<2.0.0,>=1.50.0
-Requires-Dist: openai>=1.50.0
+Requires-Dist: openai<2,>=1.66.0
 Requires-Dist: psycopg-pool>=3.2.0
 Requires-Dist: psycopg[binary]>=3.2.0
 Requires-Dist: pydantic-settings>=2.0.0

{argus_code_review-0.2.5 → 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.5 → argus_code_review-0.2.7}/pyproject.toml

@@ -46,7 +46,7 @@ dependencies = [
     # HTTP client (GitHub API, storage HTTP shim)
     "httpx>=0.27.0",
     # OpenAI SDK for the plan-extraction fallback path
-    "openai>=1.50.0",
+    "openai>=1.66.0,<2",
     # Per-token model pricing table (argus/llm/pricing.py) -- single source
     # of truth for $/token rates, instead of a hand-maintained duplicate.
     "litellm>=1.50.0,<2.0.0",

{argus_code_review-0.2.5 → 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.5 → 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()

{argus_code_review-0.2.5 → argus_code_review-0.2.7}/tests/test_openai_client.py

@@ -80,3 +80,41 @@ class TestGetAsyncOpenAIClientBaseURL:
 
         mock_async_openai.assert_called_once()
         assert mock_async_openai.call_args.kwargs["base_url"] is None
+
+
+class TestOpenAIClientSyncRespond:
+    def test_respond_passes_text_format_to_responses_create(self) -> None:
+        """text_format is wrapped in text={'format': text_format} for client.responses.create."""
+        settings = _make_settings(None)
+        mock_response = MagicMock()
+        mock_response.model = "gpt-5.4-mini"
+        mock_response.status = "completed"
+        mock_response.output = []
+        mock_response.output_text = "{}"
+
+        mock_client_instance = MagicMock()
+        mock_client_instance.responses.create.return_value = mock_response
+
+        text_format = {
+            "type": "json_schema",
+            "name": "test_schema",
+            "strict": True,
+            "schema": {"type": "object", "properties": {}},
+        }
+
+        with (
+            patch("argus.openai_client.get_settings", return_value=settings),
+            patch("argus.openai_client.OpenAI", return_value=mock_client_instance),
+            patch("argus.openai_client.wrap_openai", side_effect=lambda client: client),
+        ):
+            client = OpenAIClientSync()
+            resp = client.respond(
+                input="test prompt",
+                text_format=text_format,
+            )
+
+        mock_client_instance.responses.create.assert_called_once()
+        call_kwargs = mock_client_instance.responses.create.call_args.kwargs
+        assert call_kwargs["text"] == {"format": text_format}
+        assert call_kwargs["input"] == "test prompt"
+        assert resp == mock_response

argus_code_review-0.2.7/tests/test_output_models.py

@@ -0,0 +1,188 @@
+"""Tests for argus.llm.output_models: schema generation and Responses API format.
+
+Verifies pydantic_to_response_format (including exclude= and strict= handling)
+and LLMOutputModel schema generation for compatibility with OpenAI Responses API.
+"""
+
+from __future__ import annotations
+
+from typing import Literal
+from pydantic import BaseModel, Field
+
+from argus.graph import _PIPELINE_ONLY_RESPONSE_FIELDS
+from argus.llm.output_models import (
+    LLMOutputModel,
+    make_schema_strict,
+    pydantic_to_response_format,
+)
+from argus.models import ReviewResponse
+
+
+class SampleModel(BaseModel):
+    name: str = Field(description="The name")
+    count: int = Field(default=0, description="The count")
+    tag: str | None = None
+
+
+class SampleModelWithExcludedFields(BaseModel):
+    title: str
+    verdict: str
+    dropped_field_1: dict[str, float] = Field(default_factory=dict)
+    dropped_field_2: dict[str, float] = Field(default_factory=dict)
+
+
+class SampleOutputModel(LLMOutputModel):
+    _schema_name = "custom_output"
+
+    summary: str = Field(description="Summary of results")
+    status: Literal["pass", "fail"] = Field(description="Pass or fail")
+
+
+class TestPydanticToResponseFormat:
+    def test_default_name_and_strict(self) -> None:
+        """pydantic_to_response_format defaults name to model name in lowercase and strict=True."""
+        rf = pydantic_to_response_format(SampleModel)
+
+        assert rf["type"] == "json_schema"
+        assert rf["name"] == "samplemodel"
+        assert rf["strict"] is True
+        schema = rf["schema"]
+        assert schema["type"] == "object"
+        assert schema["additionalProperties"] is False
+        assert set(schema["required"]) == set(schema["properties"].keys())
+
+    def test_custom_name(self) -> None:
+        """pydantic_to_response_format respects custom name."""
+        rf = pydantic_to_response_format(SampleModel, name="my_custom_schema")
+        assert rf["name"] == "my_custom_schema"
+
+    def test_strict_false(self) -> None:
+        """pydantic_to_response_format respects strict=False."""
+        rf = pydantic_to_response_format(SampleModel, strict=False)
+        assert rf["strict"] is False
+        # strict=False does not enforce additionalProperties: false
+        assert rf["schema"].get("additionalProperties") is not False
+
+    def test_exclude_fields(self) -> None:
+        """exclude= removes specified fields from schema properties and required."""
+        rf = pydantic_to_response_format(
+            SampleModelWithExcludedFields,
+            name="filtered_model",
+            exclude={"dropped_field_1", "dropped_field_2"},
+        )
+
+        properties = rf["schema"]["properties"]
+        assert "title" in properties
+        assert "verdict" in properties
+        assert "dropped_field_1" not in properties
+        assert "dropped_field_2" not in properties
+
+        required = rf["schema"]["required"]
+        assert "title" in required
+        assert "verdict" in required
+        assert "dropped_field_1" not in required
+        assert "dropped_field_2" not in required
+
+    def test_review_response_with_pipeline_only_fields_excluded(self) -> None:
+        """ReviewResponse with _PIPELINE_ONLY_RESPONSE_FIELDS matches production graph.py usage."""
+        rf = pydantic_to_response_format(
+            ReviewResponse,
+            "review_response",
+            exclude=_PIPELINE_ONLY_RESPONSE_FIELDS,
+        )
+
+        assert rf["type"] == "json_schema"
+        assert rf["name"] == "review_response"
+        assert rf["strict"] is True
+
+        properties = rf["schema"]["properties"]
+        required = rf["schema"]["required"]
+
+        for excluded in _PIPELINE_ONLY_RESPONSE_FIELDS:
+            assert excluded not in properties
+            assert excluded not in required
+
+        # Essential ReviewResponse fields must remain present and required
+        assert "verdict" in properties
+        assert "verdict" in required
+        assert "risk_level" in properties
+        assert "risk_level" in required
+        assert "findings" in properties
+        assert "findings" in required
+
+
+class TestLLMOutputModel:
+    def test_to_prompt_schema(self) -> None:
+        """to_prompt_schema generates markdown with field definitions and example."""
+        schema_text = SampleOutputModel.to_prompt_schema()
+        assert "Your output MUST be valid JSON" in schema_text
+        assert "| `summary` | string |" in schema_text
+        assert "| `status` | enum |" in schema_text
+        assert (
+            "custom_output" not in schema_text
+        )  # schema name is in API response_format, not prompt
+
+    def test_to_response_format(self) -> None:
+        """to_response_format produces Chat Completions nested format."""
+        rf = SampleOutputModel.to_response_format()
+        assert rf["type"] == "json_schema"
+        assert "json_schema" in rf
+        assert rf["json_schema"]["name"] == "custom_output"
+        assert rf["json_schema"]["strict"] is True
+
+    def test_to_response_format_flat(self) -> None:
+        """to_response_format_flat produces Responses API flat format."""
+        rf = SampleOutputModel.to_response_format_flat()
+        assert rf["type"] == "json_schema"
+        assert rf["name"] == "custom_output"
+        assert rf["strict"] is True
+        assert "schema" in rf
+        assert rf["schema"]["type"] == "object"
+        assert rf["schema"]["additionalProperties"] is False
+
+
+class TestMakeSchemaStrict:
+    def test_recursively_sets_additional_properties_false_and_required(self) -> None:
+        """make_schema_strict sets additionalProperties=False and required on all objects."""
+        schema = {
+            "type": "object",
+            "properties": {
+                "user": {
+                    "type": "object",
+                    "properties": {
+                        "name": {"type": "string"},
+                    },
+                },
+                "items": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "id": {"type": "integer"},
+                        },
+                    },
+                },
+            },
+        }
+
+        strict_schema = make_schema_strict(schema)
+
+        assert strict_schema["additionalProperties"] is False
+        assert set(strict_schema["required"]) == {"user", "items"}
+
+        user_prop = strict_schema["properties"]["user"]
+        assert user_prop["additionalProperties"] is False
+        assert user_prop["required"] == ["name"]
+
+        item_schema = strict_schema["properties"]["items"]["items"]
+        assert item_schema["additionalProperties"] is False
+        assert item_schema["required"] == ["id"]
+
+    def test_ref_clears_sibling_keywords(self) -> None:
+        """OpenAI strict mode requires $ref to have no sibling keywords."""
+        schema = {
+            "$ref": "#/$defs/SomeType",
+            "description": "Sibling keyword that OpenAI rejects in strict mode",
+        }
+        strict_schema = make_schema_strict(schema)
+        assert strict_schema == {"$ref": "#/$defs/SomeType"}