argus-code-review 0.2.9__tar.gz → 0.2.11__tar.gz

{argus_code_review-0.2.9 → argus_code_review-0.2.11}/CHANGELOG.md

@@ -7,6 +7,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.11] - 2026-10-12
+
+### Fixed
+
+- The bench-config-change guard (TECH-6282) no longer fails closed on a file whose
+  patch GitHub's compare API omits (diff too large) when the repo has explicitly
+  declared that file generated/non-diffable via `.gitattributes`
+  (`linguist-generated=true` / `-diff`) — the same signal other AI review tools
+  (e.g. Cubic) already honor to skip generated files. Previously, any oversized
+  file anywhere in a PR's diff (e.g. a large Drizzle-generated migration snapshot,
+  unrelated to Argus's own bench config) forced every review round to BLOCKING
+  with no way out, since the guard treated "missing patch" as suspicious
+  regardless of whether the file was remotely bench-related. The real
+  bench-config-path check (`_is_bench_config_path`) is unaffected: a genuine
+  bench config file can't hide behind a `.gitattributes` declaration. (TECH-7402)
+
+## [0.2.10] - 2026-10-03
+
+### Fixed
+
+- Fixed structured output generation on Claude 5.5 (`claude-opus-5-5`, `claude-sonnet-5-5`) across the planner, preflight, and coverage stages (TECH-7156, #33):
+  - Migrated `plan_review`, `run_preflight_check`, and `check_coverage` to Anthropic native JSON-schema output (`output_config.format` with `type="json_schema"`) instead of unsupported forced tool choice (`tool_choice`).
+  - Preserved planner raw streaming, strict validation, repair fallback via OpenAI, truncation detection with transient retry (`PlannerTransientError`), and stage usage accounting.
+  - Added targeted regression coverage for streamed native structured output chunk shapes and non-streaming native JSON-schema stage bindings (`tests/test_plan_review.py`, `tests/test_structured_output_methods.py`).
+  - Updated architecture documentation (`docs/ARCHITECTURE.md`) to reflect native structured output for the planner.
+  - End-to-end evidence: verified via a full Argus branch review through the Redesign Health Anthropic proxy with model overrides unset (the RH proxy itself was unchanged).
+
 ## [0.2.9] - 2026-10-02
 
 ### Changed
@@ -380,7 +407,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.9...HEAD
+[Unreleased]: https://github.com/redesignhealth/argus-review/compare/v0.2.11...HEAD
+[0.2.11]: https://github.com/redesignhealth/argus-review/compare/v0.2.10...v0.2.11
+[0.2.10]: https://github.com/redesignhealth/argus-review/compare/v0.2.9...v0.2.10
 [0.2.9]: https://github.com/redesignhealth/argus-review/compare/v0.2.8...v0.2.9
 [0.2.8]: https://github.com/redesignhealth/argus-review/compare/v0.2.7...v0.2.8
 [0.2.7]: https://github.com/redesignhealth/argus-review/compare/v0.2.6...v0.2.7

{argus_code_review-0.2.9 → argus_code_review-0.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: argus-code-review
-Version: 0.2.9
+Version: 0.2.11
 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.9 → argus_code_review-0.2.11}/argus/graph.py

@@ -27,6 +27,7 @@ parameters, making add_node() calls report spurious arg-type errors.
 
 import asyncio
 import base64
+import contextlib
 import json
 import logging
 import operator
@@ -54,7 +55,7 @@ from argus.llm.usage import (
 )
 
 from langchain.chat_models import init_chat_model
-from anthropic import APIConnectionError, APITimeoutError
+from anthropic import APIConnectionError, APITimeoutError, transform_schema
 from langgraph.graph import END, START, StateGraph
 from sqlalchemy.exc import ProgrammingError
 from langgraph.types import RetryPolicy, Send
@@ -1080,9 +1081,9 @@ async def plan_review(diff: str, description: str) -> ReviewPlan:
 
     Two-phase pattern mirroring the writer at ``write_review``:
 
-    1. Phase 1 — Opus emits the plan via streamed ``bind_tools`` tool-use so
-       we receive the raw JSON text of the tool-call args directly, rather
-       than routing through ``with_structured_output`` (which strict-parses
+    1. Phase 1 — Opus emits the plan via streamed native structured output
+       (``output_config.format``) so we receive the raw JSON text directly,
+       rather than routing through ``with_structured_output`` (which strict-parses
        the wire body via the Anthropic SDK and dies on invalid escape
        sequences Opus occasionally emits, e.g. ``\\s`` inside a string).
     2. Phase 2 — attempt a strict Pydantic parse; if it fails (invalid
@@ -1093,29 +1094,73 @@ async def plan_review(diff: str, description: str) -> ReviewPlan:
     """
     prompt = await fetch_prompt("pr-review-planner")
     messages = _build_planner_messages(prompt, diff, description)
+    # Anthropic native structured output config for ReviewPlan.
+    # Note: langchain-anthropic's `with_structured_output` chains a non-streaming
+    # PydanticOutputParser, preventing raw JSON stream capture needed for
+    # truncation detection and OpenAI JSON-escape repair fallback. Rather than
+    # importing langchain-anthropic's private `_convert_to_anthropic_output_config_format`,
+    # we use the public `anthropic.transform_schema` to construct native `output_config.format`.
     model = (
         _get_llm(_PLANNER_MODEL, "planner")
-        .bind_tools([ReviewPlan], tool_choice="ReviewPlan")
+        .bind(
+            output_config={
+                "format": {
+                    "type": "json_schema",
+                    "schema": transform_schema(ReviewPlan),
+                }
+            }
+        )
         .with_config(
             run_name="planner-phase1-stream",
-            tags=["planner", "bind_tools", "json-escape-repair"],
+            tags=["planner", "native_structured_output", "json-escape-repair"],
         )
     )
 
-    # Only collect args from the first tool-call slot (index 0). tool_choice
-    # pins the model to a single tool, but guarding by index is cheap
-    # defense against the model ever emitting multiple tool calls.
+    # Native output streams JSON as text content. Collect string text and
+    # text content blocks, while preserving legacy tool_call_chunks handling
+    # for backwards/mock compatibility. If a chunk exposes text content,
+    # tool_call_chunks are skipped for that chunk to avoid double-counting.
     raw_json_parts: list[str] = []
     dropped_nonzero_indices: set[int] = set()
     async for chunk in model.astream(messages):
-        for tc_chunk in getattr(chunk, "tool_call_chunks", []):
-            idx = tc_chunk.get("index", 0)
-            if idx != 0:
-                dropped_nonzero_indices.add(idx)
-                continue
-            args = tc_chunk.get("args")
-            if args:
-                raw_json_parts.append(args)
+        text_piece = ""
+        content = getattr(chunk, "content", None)
+        if isinstance(content, str):
+            text_piece = content
+        elif isinstance(content, list):
+            pieces: list[str] = []
+            for block in content:
+                if isinstance(block, str):
+                    pieces.append(block)
+                elif isinstance(block, dict):
+                    block_type = block.get("type")
+                    if (block_type is None or block_type == "text") and isinstance(
+                        block.get("text"), str
+                    ):
+                        pieces.append(block["text"])
+                elif hasattr(block, "text") and isinstance(getattr(block, "text"), str):
+                    block_type = getattr(block, "type", None)
+                    if block_type is None or block_type == "text":
+                        pieces.append(block.text)
+            text_piece = "".join(pieces)
+        elif hasattr(chunk, "text") and isinstance(getattr(chunk, "text"), str):
+            text_piece = chunk.text
+
+        if text_piece:
+            raw_json_parts.append(text_piece)
+        else:
+            for tc_chunk in getattr(chunk, "tool_call_chunks", []) or []:
+                if isinstance(tc_chunk, dict):
+                    idx = tc_chunk.get("index", 0)
+                    args = tc_chunk.get("args")
+                else:
+                    idx = getattr(tc_chunk, "index", 0)
+                    args = getattr(tc_chunk, "args", None)
+                if idx != 0:
+                    dropped_nonzero_indices.add(idx)
+                    continue
+                if args:
+                    raw_json_parts.append(args)
 
     if dropped_nonzero_indices:
         logger.warning(
@@ -1127,29 +1172,29 @@ async def plan_review(diff: str, description: str) -> ReviewPlan:
     raw_json = "".join(raw_json_parts)
     if not raw_json:
         logger.error(
-            "Planner produced no tool-use output; model=%s tool=ReviewPlan",
+            "Planner produced no structured output; model=%s schema=ReviewPlan",
             _PLANNER_MODEL,
         )
         raise ValueError(
-            "Planner produced no tool-use output — model may have returned a "
-            "plain text response instead of calling the ReviewPlan tool."
+            "Planner produced no structured output — model returned no JSON "
+            "content matching the ReviewPlan schema."
         )
 
     # Truncation guard: a mid-stream failure can leave raw_json syntactically
     # parseable at the top level but missing tail content. A complete
-    # tool-use JSON object must start with `{` and end with `}` after
+    # structured output JSON object must start with `{` and end with `}` after
     # whitespace trim. If it doesn't, the stream was cut off — fail loud
     # rather than feed partial JSON to the fallback repair step.
     stripped = raw_json.strip()
     if not (stripped.startswith("{") and stripped.endswith("}")):
         logger.error(
-            "Planner tool-use output appears truncated; length=%d starts_with=%r ends_with=%r",
+            "Planner structured output appears truncated; length=%d starts_with=%r ends_with=%r",
             len(raw_json),
             stripped[:1],
             stripped[-1:] if stripped else "",
         )
         raise PlannerTransientError(
-            "Planner tool-use output appears truncated (does not start with "
+            "Planner structured output appears truncated (does not start with "
             "'{' and end with '}') — stream likely terminated mid-response."
         )
 
@@ -1339,7 +1384,9 @@ async def check_coverage(
     )
 
     prompt = await fetch_prompt("pr-review-coverage-check")
-    model = _get_llm(_COVERAGE_MODEL, "coverage").with_structured_output(CoverageResult)
+    model = _get_llm(_COVERAGE_MODEL, "coverage").with_structured_output(
+        CoverageResult, method="json_schema"
+    )
     messages = [
         {"role": "system", "content": prompt},
         *_build_coverage_messages(plan, findings, sorted(uncovered)),
@@ -1445,7 +1492,7 @@ async def run_preflight_check(
     prompt = await fetch_prompt("pr-review-preflight-router")
     llm = _get_llm(
         f"anthropic:{CLAUDE_DEFAULT}", "preflight", max_tokens=256, temperature=0
-    ).with_structured_output(PreflightResult)
+    ).with_structured_output(PreflightResult, method="json_schema")
     prior_context = (
         f"Prior round verdict: {prior_verdict}" if prior_verdict else "No prior review (round 1)"
     )
@@ -2047,6 +2094,62 @@ def _detect_bench_config_routing_lines(diff: str) -> list[str]:
     return matches
 
 
+async def _is_generated_nodiff_path(worktree_path: str | None, filename: str) -> bool:
+    """Return True if the repo itself declares ``filename`` generated/non-diffable.
+
+    A file whose patch GitHub's compare API omits (diff too large) is otherwise
+    treated as bench-config-unconfirmed below regardless of whether the file is
+    remotely bench-related -- this fires for any oversized file anywhere in the
+    diff, e.g. a large auto-generated migration snapshot unrelated to Argus's own
+    config. Repos already have a standard, explicit, auditable way to declare a
+    file generated-and-not-meaningfully-diffable: ``.gitattributes``
+    ``linguist-generated=true`` / ``-diff``. Honor that signal here so a
+    missing-patch file only stays unconfirmed (and forces BLOCKING) when the repo
+    hasn't already declared it non-diffable. This does NOT weaken
+    ``_is_bench_config_path`` above, which matches on filename regardless of patch
+    content or gitattributes -- a real bench config file can't hide behind this.
+    """
+    if not worktree_path:
+        return False
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            "git",
+            "-C",
+            worktree_path,
+            "check-attr",
+            "diff",
+            "linguist-generated",
+            "--",
+            filename,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        try:
+            stdout, _ = await asyncio.wait_for(proc.communicate(), timeout=5)
+        except (asyncio.TimeoutError, TimeoutError):
+            proc.kill()
+            with contextlib.suppress(Exception):
+                await proc.communicate()
+            return False
+    except Exception:
+        return False
+    if proc.returncode != 0:
+        return False
+    diff_unset = False
+    linguist_generated = False
+    for line in stdout.decode(errors="replace").splitlines():
+        # Format: "<path>: <attr>: <value>"
+        parts = line.split(": ", 2)
+        if len(parts) != 3:
+            continue
+        _, attr, value = parts
+        if attr == "diff" and value == "unset":
+            diff_unset = True
+        elif attr == "linguist-generated" and value == "true":
+            linguist_generated = True
+    return diff_unset or linguist_generated
+
+
 def _is_high_blast_radius(diff: str) -> str | None:
     r"""Return the first changed path that matches a high-blast-radius pattern, or None.
 
@@ -2321,6 +2424,12 @@ async def _node_fetch_diff(state: ReviewState, config: RunnableConfig) -> dict[s
                 bench_config_changes.append(
                     f"added line modifying bench routing in {filename}: {line}"
                 )
+        elif await _is_generated_nodiff_path(worktree_path, filename):
+            logger.info(
+                "Missing patch content for '%s' ignored for bench-config verification: "
+                "repo declares it generated/non-diffable via .gitattributes",
+                filename,
+            )
         elif not unconfirmed_reason and filename not in bench_config_changes:
             unconfirmed_reason = (
                 f"Diff patch content missing or empty for '{filename}' in GitHub API "

{argus_code_review-0.2.9 → argus_code_review-0.2.11}/tests/test_bench_config_guard.py

@@ -13,6 +13,7 @@ Covers:
 
 from __future__ import annotations
 
+import subprocess
 from typing import Any
 from unittest.mock import AsyncMock, MagicMock, patch
 
@@ -21,6 +22,7 @@ import pytest
 from argus.graph import (
     _detect_bench_config_routing_lines,
     _is_bench_config_path,
+    _is_generated_nodiff_path,
     _node_fetch_diff,
     run_review,
 )
@@ -607,6 +609,130 @@ class TestMultiRoundBenchConfigGuardRegressions:
         assert fired is False
         assert response.verdict == Verdict.APPROVE
 
+    @pytest.mark.asyncio
+    async def test_missing_patch_on_gitattributes_generated_file_does_not_fail_closed(
+        self, tmp_path: Any
+    ) -> None:
+        """A file the repo declares generated/non-diffable via .gitattributes must NOT fail
+        closed just because GitHub omitted its patch (e.g. a large Drizzle/ORM migration
+        snapshot)."""
+        subprocess.run(["git", "init", "-q", str(tmp_path)], check=True)
+        (tmp_path / ".gitattributes").write_text(
+            "migrations/meta/*.json linguist-generated=true -diff\n"
+        )
+        generated_path = tmp_path / "migrations" / "meta"
+        generated_path.mkdir(parents=True)
+        (generated_path / "0001_snapshot.json").write_text("{}")
+
+        req = ReviewRequest(repo="org/repo", pr_number=42)
+        diff = (
+            "diff --git a/migrations/meta/0001_snapshot.json b/migrations/meta/0001_snapshot.json\n"
+        )
+
+        mock_gh = MagicMock()
+        mock_gh.get_compare_files.return_value = (
+            [
+                {
+                    "filename": "migrations/meta/0001_snapshot.json",
+                    "status": "modified",
+                    "patch": None,
+                }
+            ],
+            False,
+        )
+
+        state = {"request": req.model_dump()}
+        config: dict[str, Any] = {"configurable": {"worktree_path": str(tmp_path)}}
+
+        with (
+            patch("argus.graph._fetch_prior_review", new_callable=AsyncMock, return_value=None),
+            patch("argus.graph._fetch_dismissed_findings", new_callable=AsyncMock, return_value=[]),
+            patch(
+                "argus.graph._fetch_pr_diff_and_description",
+                new_callable=AsyncMock,
+                return_value=(diff, "desc", "head12345678", "main"),
+            ),
+            patch(_GH_CLIENT_CLASS, return_value=mock_gh),
+        ):
+            node_result = await _node_fetch_diff(state, config)
+
+        assert node_result["bench_config_unconfirmed"] is None
+        assert node_result["bench_config_changes"] == []
+
+        response = _make_response(verdict=Verdict.APPROVE)
+        fired = apply_bench_config_change_gate(
+            response, node_result["bench_config_changes"], node_result["bench_config_unconfirmed"]
+        )
+        assert fired is False
+        assert response.verdict == Verdict.APPROVE
+
+    @pytest.mark.asyncio
+    async def test_missing_patch_without_worktree_still_fails_closed(self) -> None:
+        """No worktree_path (e.g. an older call path) means the gitattributes exemption
+        can't be checked, so the existing fail-closed behavior must still apply."""
+        req = ReviewRequest(repo="org/repo", pr_number=42)
+        diff = (
+            "diff --git a/migrations/meta/0001_snapshot.json b/migrations/meta/0001_snapshot.json\n"
+        )
+
+        mock_gh = MagicMock()
+        mock_gh.get_compare_files.return_value = (
+            [
+                {
+                    "filename": "migrations/meta/0001_snapshot.json",
+                    "status": "modified",
+                    "patch": None,
+                }
+            ],
+            False,
+        )
+
+        state = {"request": req.model_dump()}
+        config: dict[str, Any] = {"configurable": {}}
+
+        with (
+            patch("argus.graph._fetch_prior_review", new_callable=AsyncMock, return_value=None),
+            patch("argus.graph._fetch_dismissed_findings", new_callable=AsyncMock, return_value=[]),
+            patch(
+                "argus.graph._fetch_pr_diff_and_description",
+                new_callable=AsyncMock,
+                return_value=(diff, "desc", "head12345678", "main"),
+            ),
+            patch(_GH_CLIENT_CLASS, return_value=mock_gh),
+        ):
+            node_result = await _node_fetch_diff(state, config)
+
+        assert node_result["bench_config_unconfirmed"] is not None
+        assert "Diff patch content missing or empty" in node_result["bench_config_unconfirmed"]
+
+
+class TestIsGeneratedNodiffPath:
+    """Unit tests for _is_generated_nodiff_path."""
+
+    @pytest.mark.asyncio
+    async def test_no_worktree_path_returns_false(self) -> None:
+        assert await _is_generated_nodiff_path(None, "some/file.json") is False
+
+    @pytest.mark.asyncio
+    async def test_linguist_generated_true_returns_true(self, tmp_path: Any) -> None:
+        subprocess.run(["git", "init", "-q", str(tmp_path)], check=True)
+        (tmp_path / ".gitattributes").write_text("big.json linguist-generated=true -diff\n")
+        (tmp_path / "big.json").write_text("{}")
+
+        assert await _is_generated_nodiff_path(str(tmp_path), "big.json") is True
+
+    @pytest.mark.asyncio
+    async def test_unrelated_file_returns_false(self, tmp_path: Any) -> None:
+        subprocess.run(["git", "init", "-q", str(tmp_path)], check=True)
+        (tmp_path / ".gitattributes").write_text("big.json linguist-generated=true -diff\n")
+        (tmp_path / "other.py").write_text("x = 1\n")
+
+        assert await _is_generated_nodiff_path(str(tmp_path), "other.py") is False
+
+    @pytest.mark.asyncio
+    async def test_non_git_directory_returns_false(self, tmp_path: Any) -> None:
+        assert await _is_generated_nodiff_path(str(tmp_path), "whatever.json") is False
+
 
 class TestRunReviewBenchGuardIntegration:
     """Integration test for run_review executing the bench config change gate."""

{argus_code_review-0.2.9 → argus_code_review-0.2.11}/tests/test_llm_models.py

@@ -7,6 +7,7 @@ cost-estimation surface.
 
 from __future__ import annotations
 
+import litellm
 import pytest
 
 from argus.llm.models import (
@@ -49,12 +50,13 @@ class TestPricingLookup:
 
     def test_claude_default_pricing_rates(self) -> None:
         """Regression guard: claude-sonnet-5-5 rates in litellm must match
-        expected rates ($2/$10/$0.20 per Mtok)."""
+        expected rates ($2/$10/$0.10 per Mtok). Anthropic lowered the cache-read
+        rate from $0.20 to $0.10 on 2026-10-07 (litellm#45113)."""
         cost = get_token_cost(ALIAS_MAP["claude-default"])
         assert cost is not None
         assert cost.input_cost_per_token == pytest.approx(2e-6)
         assert cost.output_cost_per_token == pytest.approx(10e-6)
-        assert cost.cache_read_cost_per_token == pytest.approx(0.2e-6)
+        assert cost.cache_read_cost_per_token == pytest.approx(0.1e-6)
 
     def test_claude_opus_5_5_pricing_rates(self) -> None:
         """Regression guard: claude-opus-5-5 rates in litellm must match
@@ -85,13 +87,28 @@ class TestPricingLookup:
         assert cost.cache_read_cost_per_token < cost.input_cost_per_token
 
 
+@pytest.fixture
+def fixed_claude_default_rates(monkeypatch: pytest.MonkeyPatch) -> None:
+    """litellm.model_cost is fetched live at import, so pin the row used by the
+    arithmetic tests; only the TestPricingLookup guards read live rates."""
+    row = {
+        "input_cost_per_token": 2e-6,
+        "output_cost_per_token": 10e-6,
+        "cache_read_input_token_cost": 0.1e-6,
+        "cache_creation_input_token_cost": 2.5e-6,
+    }
+    monkeypatch.setitem(litellm.model_cost, ALIAS_MAP["claude-default"], row)
+
+
 class TestEstimateCostUsd:
+    @pytest.mark.usefixtures("fixed_claude_default_rates")
     def test_computes_expected_cost_for_claude_default(self) -> None:
         cost = estimate_cost_usd(
             ALIAS_MAP["claude-default"], input_tokens=1_000_000, output_tokens=1_000_000
         )
         assert cost == pytest.approx(2.00 + 10.00)
 
+    @pytest.mark.usefixtures("fixed_claude_default_rates")
     def test_cached_input_tokens_billed_separately_at_cache_read_rate(self) -> None:
         """cached_input_tokens is additive (billed at the cache-read rate),
         not a subset subtracted from input_tokens."""
@@ -101,8 +118,9 @@ class TestEstimateCostUsd:
             output_tokens=0,
             cached_input_tokens=1_000_000,
         )
-        assert cost == pytest.approx(2.00 + 0.20)
+        assert cost == pytest.approx(2.00 + 0.10)
 
+    @pytest.mark.usefixtures("fixed_claude_default_rates")
     def test_cache_creation_tokens_billed(self) -> None:
         """cache_creation_tokens is billed at the cache-creation rate."""
         cost = estimate_cost_usd(