code-review-ai-cli 2.2.3__tar.gz → 2.2.5__tar.gz

{code_review_ai_cli-2.2.3 → code_review_ai_cli-2.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-review-ai-cli
-Version: 2.2.3
+Version: 2.2.5
 Summary: Automated AI-powered code review CLI for Azure DevOps / TFS Pull Requests
 License: MIT
 Keywords: code-review,ai,azure-devops,tfs,pull-request,llm
@@ -55,7 +55,8 @@ AI Code Review is an automated AI-powered code review CLI, compatible with vario
 - Configuration exclusively via `config.yaml`
 - Providers LLM: OpenAI, Azure OpenAI, Gemini, Claude, Ollama, GitHub Copilot, AWS Bedrock
 - Diff filtering by **excluded path prefixes** (`excluded_paths`) and/or **file extensions** (`file_extensions_filter`)
-- Prompt token estimation with LiteLLM (`Total Prompt`)
+- Prompt token consumption estimation with LiteLLM (`Total Tokens`)
+- Validation to ensure comments are not duplicated in re-runs (CI/CD Pipelines)
 
 ## Documentation
 
@@ -68,12 +69,6 @@ AI Code Review is an automated AI-powered code review CLI, compatible with vario
 
 ![Review Output Format Example](/imgs/review_output.png)
 
-During a PR review, the terminal also displays `Total Prompt`, an estimate of
-the input tokens in the complete payload sent to the configured provider. The
-provider comes from `llm.provider` and the model comes from `llm.model` or its
-default one. If LiteLLM cannot resolve the provider/model combination,
-the tool tries the model without a provider prefix and then uses local
-`tiktoken` as a final fallback.
 
 ## Installation
 
@@ -157,5 +152,5 @@ output:
 - `AI Review: List Active PRs`
 - `AI Review: Interactive Mode`
 
-## Licence
+## License
 This project is licensed under the Apache Licence 2.0 — see the [LICENSE](/License).

{code_review_ai_cli-2.2.3 → code_review_ai_cli-2.2.5}/README.md

@@ -11,7 +11,8 @@ AI Code Review is an automated AI-powered code review CLI, compatible with vario
 - Configuration exclusively via `config.yaml`
 - Providers LLM: OpenAI, Azure OpenAI, Gemini, Claude, Ollama, GitHub Copilot, AWS Bedrock
 - Diff filtering by **excluded path prefixes** (`excluded_paths`) and/or **file extensions** (`file_extensions_filter`)
-- Prompt token estimation with LiteLLM (`Total Prompt`)
+- Prompt token consumption estimation with LiteLLM (`Total Tokens`)
+- Validation to ensure comments are not duplicated in re-runs (CI/CD Pipelines)
 
 ## Documentation
 
@@ -24,12 +25,6 @@ AI Code Review is an automated AI-powered code review CLI, compatible with vario
 
 ![Review Output Format Example](/imgs/review_output.png)
 
-During a PR review, the terminal also displays `Total Prompt`, an estimate of
-the input tokens in the complete payload sent to the configured provider. The
-provider comes from `llm.provider` and the model comes from `llm.model` or its
-default one. If LiteLLM cannot resolve the provider/model combination,
-the tool tries the model without a provider prefix and then uses local
-`tiktoken` as a final fallback.
 
 ## Installation
 
@@ -113,5 +108,5 @@ output:
 - `AI Review: List Active PRs`
 - `AI Review: Interactive Mode`
 
-## Licence
+## License
 This project is licensed under the Apache Licence 2.0 — see the [LICENSE](/License).

{code_review_ai_cli-2.2.3 → code_review_ai_cli-2.2.5}/code_review_ai_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-review-ai-cli
-Version: 2.2.3
+Version: 2.2.5
 Summary: Automated AI-powered code review CLI for Azure DevOps / TFS Pull Requests
 License: MIT
 Keywords: code-review,ai,azure-devops,tfs,pull-request,llm
@@ -55,7 +55,8 @@ AI Code Review is an automated AI-powered code review CLI, compatible with vario
 - Configuration exclusively via `config.yaml`
 - Providers LLM: OpenAI, Azure OpenAI, Gemini, Claude, Ollama, GitHub Copilot, AWS Bedrock
 - Diff filtering by **excluded path prefixes** (`excluded_paths`) and/or **file extensions** (`file_extensions_filter`)
-- Prompt token estimation with LiteLLM (`Total Prompt`)
+- Prompt token consumption estimation with LiteLLM (`Total Tokens`)
+- Validation to ensure comments are not duplicated in re-runs (CI/CD Pipelines)
 
 ## Documentation
 
@@ -68,12 +69,6 @@ AI Code Review is an automated AI-powered code review CLI, compatible with vario
 
 ![Review Output Format Example](/imgs/review_output.png)
 
-During a PR review, the terminal also displays `Total Prompt`, an estimate of
-the input tokens in the complete payload sent to the configured provider. The
-provider comes from `llm.provider` and the model comes from `llm.model` or its
-default one. If LiteLLM cannot resolve the provider/model combination,
-the tool tries the model without a provider prefix and then uses local
-`tiktoken` as a final fallback.
 
 ## Installation
 
@@ -157,5 +152,5 @@ output:
 - `AI Review: List Active PRs`
 - `AI Review: Interactive Mode`
 
-## Licence
+## License
 This project is licensed under the Apache Licence 2.0 — see the [LICENSE](/License).

{code_review_ai_cli-2.2.3 → code_review_ai_cli-2.2.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code-review-ai-cli"
-version = "2.2.3"
+version = "2.2.5"
 description = "Automated AI-powered code review CLI for Azure DevOps / TFS Pull Requests"
 readme = "README.md"
 requires-python = ">=3.10"

{code_review_ai_cli-2.2.3 → code_review_ai_cli-2.2.5}/src/ai_review.py

@@ -595,8 +595,15 @@ def run_pr_review_workflow(args: argparse.Namespace, config: ReviewConfig,
             f"---\n"
             f"*Automatic review generated by AI Code Review v{VERSION}*"
         )
-        tfs.post_general_comment(repo_name, pr_id, summary_comment)
-        print(formatter.format_success("General summary posted to PR."))
+        result = tfs.post_general_comment(
+            repo_name, pr_id, summary_comment, dedup_marker="summary"
+        )
+        if result.get("skipped"):
+            print(formatter.format_info(
+                "General summary already present, skipped."
+            ))
+        else:
+            print(formatter.format_success("General summary posted to PR."))
     except TFSError as exc:
         print(formatter.format_warning(f"Could not post general summary: {exc}"))
 

{code_review_ai_cli-2.2.3 → code_review_ai_cli-2.2.5}/src/formatter.py

@@ -297,7 +297,8 @@ class ReviewFormatter:
         lines = [f"\n{c.BOLD}📤 Comment posting results:{c.RESET}\n"]
 
         success_count = sum(1 for r in results if r.get("success"))
-        fail_count = len(results) - success_count
+        skipped_count = sum(1 for r in results if r.get("skipped"))
+        fail_count = len(results) - success_count - skipped_count
 
         for r in results:
             if r.get("success"):
@@ -322,6 +323,7 @@ class ReviewFormatter:
         lines.append(
             f"\n  {c.BOLD}Total: "
             f"{c.GREEN}{success_count} posted{c.RESET}, "
+            f"{c.YELLOW}{skipped_count} skipped{c.RESET}, "
             f"{c.RED}{fail_count} failed{c.RESET}"
         )
         return "\n".join(lines)

{code_review_ai_cli-2.2.3 → code_review_ai_cli-2.2.5}/src/llm_client.py

@@ -591,8 +591,9 @@ class LLMClient:
                 {"role": "user", "content": user_message},
             ],
             "max_tokens": self.config.max_tokens,
-            "temperature": self.config.temperature,
         }
+        if self.config.temperature != 99:
+            payload["temperature"] = self.config.temperature
 
         return self._http_openai_compatible(url, headers, payload)
 
@@ -637,10 +638,11 @@ class LLMClient:
                 "parts": [{"text": system_prompt}]
             },
             "generationConfig": {
-                "temperature": self.config.temperature,
                 "maxOutputTokens": self.config.max_tokens,
             },
         }
+        if self.config.temperature != 99:
+            payload["generationConfig"]["temperature"] = self.config.temperature
 
         try:
             resp = requests.post(url, headers=headers, json=payload, timeout=180)
@@ -715,12 +717,13 @@ class LLMClient:
         payload = {
             "model": model,
             "max_tokens": self.config.max_tokens,
-            "temperature": self.config.temperature,
             "system": system_prompt,
             "messages": [
                 {"role": "user", "content": user_message},
             ],
         }
+        if self.config.temperature != 99:
+            payload["temperature"] = self.config.temperature
 
         try:
             resp = requests.post(url, headers=headers, json=payload, timeout=180)
@@ -793,9 +796,10 @@ class LLMClient:
                 {"role": "system", "content": system_prompt},
                 {"role": "user", "content": user_message},
             ],
-            "temperature": self.config.temperature,
             "stream": False,
         }
+        if self.config.temperature != 99:
+            payload["temperature"] = self.config.temperature
 
         # Ollama does not require an API key, but we add max_tokens if configured
         if self.config.max_tokens:
@@ -912,8 +916,9 @@ class LLMClient:
                 {"role": "system", "content": system_prompt},
                 {"role": "user", "content": user_message},
             ],
-            "temperature": self.config.temperature,
         }
+        if self.config.temperature != 99:
+            payload["temperature"] = self.config.temperature
 
         # Add max_tokens if configured (some Copilot models
         # may not support this parameter)
@@ -1028,7 +1033,7 @@ class LLMClient:
         system_prompt: str,
         user_message: str,
     ) -> str:
-        """Calls Bedrock InvokeModel using an HTTP Bearer token (long-term API key).
+        """Calls Bedrock Converse using an HTTP Bearer token (long-term API key).
 
         Args:
             region: AWS region, e.g. ``us-east-1``.
@@ -1051,14 +1056,19 @@ class LLMClient:
 
         # The model ARN contains ':' and '/' that must be URL-encoded in the path
         model_encoded = urllib.parse.quote(self.config.model, safe="")
-        url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_encoded}/invoke"
+        url = f"https://bedrock-runtime.{region}.amazonaws.com/model/{model_encoded}/converse"
+
+        inference_config = {"maxTokens": self.config.max_tokens}
+        if self.config.temperature != 99:
+            inference_config["temperature"] = self.config.temperature
 
         payload = json.dumps({
-            "anthropic_version": "bedrock-2023-05-31",
-            "max_tokens": self.config.max_tokens,
-            "temperature": self.config.temperature,
-            "system": system_prompt,
-            "messages": [{"role": "user", "content": user_message}],
+            "system": [{"text": system_prompt}],
+            "messages": [{
+                "role": "user",
+                "content": [{"text": user_message}],
+            }],
+            "inferenceConfig": inference_config,
         }, separators=(",", ":"))
 
         headers = {
@@ -1084,10 +1094,9 @@ class LLMClient:
         except ValueError as exc:
             raise LLMError(f"Invalid JSON from Bedrock: {resp.text[:500]}") from exc
 
-        content = data.get("content", [])
+        content = data.get("output", {}).get("message", {}).get("content", [])
         text_parts = [
-            item["text"] for item in content
-            if item.get("type") == "text" and "text" in item
+            item["text"] for item in content if "text" in item
         ]
         text = "\n".join(part for part in text_parts if part).strip()
         if not text:
@@ -1103,7 +1112,7 @@ class LLMClient:
         system_prompt: str,
         user_message: str,
     ) -> str:
-        """Calls Bedrock InvokeModel with manual AWS SigV4 HMAC-SHA256 signing.
+        """Calls Bedrock Converse with manual AWS SigV4 HMAC-SHA256 signing.
 
         Equivalent to the C# BedrockLlmClient implementation.
 
@@ -1135,15 +1144,20 @@ class LLMClient:
 
         host = f"bedrock-runtime.{region}.amazonaws.com"
         model_encoded = urllib.parse.quote(self.config.model, safe="")
-        endpoint = f"https://{host}/model/{model_encoded}/invoke"
+        endpoint = f"https://{host}/model/{model_encoded}/converse"
         service = "bedrock"
 
+        inference_config = {"maxTokens": self.config.max_tokens}
+        if self.config.temperature != 99:
+            inference_config["temperature"] = self.config.temperature
+
         payload = json.dumps({
-            "anthropic_version": "bedrock-2023-05-31",
-            "max_tokens": self.config.max_tokens,
-            "temperature": self.config.temperature,
-            "system": system_prompt,
-            "messages": [{"role": "user", "content": user_message}],
+            "system": [{"text": system_prompt}],
+            "messages": [{
+                "role": "user",
+                "content": [{"text": user_message}],
+            }],
+            "inferenceConfig": inference_config,
         }, separators=(",", ":"))
 
         now = datetime.datetime.now(datetime.timezone.utc)
@@ -1157,7 +1171,7 @@ class LLMClient:
         # Splitting by '/' and encoding each segment mirrors the C# SigV4 implementation.
         canonical_uri = "/".join(
             urllib.parse.quote(seg, safe="")
-            for seg in f"/model/{self.config.model}/invoke".split("/")
+            for seg in f"/model/{self.config.model}/converse".split("/")
         )
 
         headers_to_sign = {
@@ -1227,10 +1241,9 @@ class LLMClient:
         except ValueError as exc:
             raise LLMError(f"Invalid JSON from Bedrock: {resp.text[:500]}") from exc
 
-        content = data.get("content", [])
+        content = data.get("output", {}).get("message", {}).get("content", [])
         text_parts = [
-            item["text"] for item in content
-            if item.get("type") == "text" and "text" in item
+            item["text"] for item in content if "text" in item
         ]
         text = "\n".join(part for part in text_parts if part).strip()
         if not text:
@@ -1277,6 +1290,10 @@ class LLMClient:
             session = boto3.Session(**session_kwargs)
             client = session.client("bedrock-runtime", region_name=region)
 
+            inference_config = {"maxTokens": self.config.max_tokens}
+            if self.config.temperature != 99:
+                inference_config["temperature"] = self.config.temperature
+
             response = client.converse(
                 modelId=self.config.model,
                 system=[{"text": system_prompt}],
@@ -1286,10 +1303,7 @@ class LLMClient:
                         "content": [{"text": user_message}],
                     }
                 ],
-                inferenceConfig={
-                    "temperature": self.config.temperature,
-                    "maxTokens": self.config.max_tokens,
-                },
+                inferenceConfig=inference_config,
             )
 
             content = (

{code_review_ai_cli-2.2.3 → code_review_ai_cli-2.2.5}/src/prompts/config.yaml.template

@@ -26,7 +26,7 @@ llm:
   # Maximum tokens in response
   max_tokens: 4096
 
-  # Temperature (0.0 = deterministic, 1.0 = creative)
+  # Temperature (0.0 = deterministic, 1.0 = creative, 99 omits it for all models that dont support this)
   temperature: 0.0
 
 # ---------------------------------------------------------------------------

{code_review_ai_cli-2.2.3 → code_review_ai_cli-2.2.5}/src/tfs_client.py

@@ -18,7 +18,9 @@ Works with both on-premises TFS and Azure DevOps Services.
 
 import base64
 import difflib
+import hashlib
 import os
+import re
 from typing import Optional
 
 from .config import ReviewConfig
@@ -35,6 +37,12 @@ class TFSClient:
 
     API_VERSION = "7.0"
 
+    # Hidden fingerprint marker embedded in AI-generated comments to detect
+    # and skip duplicates on pipeline re-runs. Rendered as an HTML comment,
+    # which Azure DevOps does not display in the PR UI.
+    MARKER_PREFIX = "ai-review:"
+    _MARKER_RE = re.compile(r"<!--\s*ai-review:([0-9a-zA-Z_]+)\s*-->")
+
     def __init__(self, config: ReviewConfig):
         self.config = config
         self.base_url = config.tfs_base_url.rstrip("/")
@@ -617,20 +625,36 @@ class TFSClient:
     # Pull Requests - Comments
     # ==================================================================
     def post_general_comment(self, repository: str, pr_id: int,
-                             comment: str, status: str = "active") -> dict:
+                             comment: str, status: str = "active",
+                             dedup_marker: Optional[str] = None) -> dict:
         """
         Posts a general comment on a Pull Request (not associated with a file).
-        
+
         Args:
             repository: Repository name.
             pr_id: Pull Request ID.
             comment: Comment text (supports Markdown).
             status: Thread status - "active", "fixed", "wontFix",
                     "closed", "pending", "byDesign"
-            
+            dedup_marker: Optional stable identifier. When provided, a hidden
+                          fingerprint is appended to the comment and existing PR
+                          threads are checked first; if the same marker already
+                          exists, the comment is skipped instead of duplicated.
+
         Returns:
-            Created thread data.
+            Created thread data, or a ``{"skipped": True, ...}`` dict when the
+            comment was skipped due to an already existing marker.
         """
+        marker: Optional[str] = None
+        if dedup_marker is not None:
+            marker = self._general_marker(dedup_marker)
+            existing = self._extract_existing_markers(
+                self.list_pr_threads(repository, pr_id)
+            )
+            if marker in existing:
+                return {"skipped": True, "marker": marker}
+            comment = f"{comment}\n\n{self._marker_html(marker)}"
+
         path = f"git/repositories/{repository}/pullrequests/{pr_id}/threads"
         data = {
             "comments": [
@@ -729,13 +753,29 @@ class TFSClient:
         comment_mode = (comment_mode or "structured").lower()
         use_inline_comments = comment_mode == "structured"
 
-        for c in comments:
-            # Build formatted comment text
-            text = self._format_review_comment(c)
+        # Load existing markers once to skip comments already posted in a
+        # previous run (deduplication is always active).
+        existing_markers = self._extract_existing_markers(
+            self.list_pr_threads(repository, pr_id)
+        )
 
+        for c in comments:
             file_path = c.get("file", "")
             line = c.get("line", 0)
 
+            marker = self._comment_marker(c)
+            if marker in existing_markers:
+                results.append({
+                    "skipped": True,
+                    "file": file_path,
+                    "line": line,
+                    "error": "duplicate (already posted)",
+                })
+                continue
+
+            # Build formatted comment text with the hidden fingerprint appended.
+            text = f"{self._format_review_comment(c)}\n\n{self._marker_html(marker)}"
+
             try:
                 if use_inline_comments and file_path and line > 0:
                     # Inline comment
@@ -747,6 +787,8 @@ class TFSClient:
                     result = self.post_general_comment(
                         repository, pr_id, text
                     )
+                # Record the marker to avoid duplicates within the same batch.
+                existing_markers.add(marker)
                 results.append({
                     "success": True,
                     "file": file_path,
@@ -793,6 +835,86 @@ class TFSClient:
 
         return "\n".join(parts)
 
+    # ==================================================================
+    # Deduplication - hidden fingerprint markers
+    # ==================================================================
+    def list_pr_threads(self, repository: str, pr_id: int) -> list[dict]:
+        """
+        Lists all comment threads of a Pull Request.
+
+        Args:
+            repository: Repository name.
+            pr_id: Pull Request ID.
+
+        Returns:
+            List of thread dictionaries (empty list when none exist).
+        """
+        path = f"git/repositories/{repository}/pullrequests/{pr_id}/threads"
+        response = self._get(path)
+        return response.get("value", [])
+
+    def _comment_marker(self, comment: dict) -> str:
+        """
+        Builds a stable fingerprint for a structured review comment.
+
+        The hash is derived from the file, line and type so the same finding
+        location produces the same marker across runs, regardless of small
+        wording changes in the comment text.
+
+        Args:
+            comment: Structured comment with ``file``, ``line`` and ``type`` keys.
+
+        Returns:
+            Hexadecimal SHA-256 digest string.
+        """
+        payload = "|".join([
+            str(comment.get("file", "")),
+            str(comment.get("line", "")),
+            str(comment.get("type", "")),
+        ])
+        return hashlib.sha256(payload.encode("utf-8")).hexdigest()
+
+    def _general_marker(self, identifier: str) -> str:
+        """
+        Builds a stable marker for a general comment from a fixed identifier.
+
+        Args:
+            identifier: Stable identifier (e.g. ``"summary"``).
+
+        Returns:
+            Sanitized marker string usable inside the HTML comment.
+        """
+        return re.sub(r"[^0-9a-zA-Z_]", "_", identifier)
+
+    def _marker_html(self, marker: str) -> str:
+        """
+        Wraps a marker into a hidden HTML comment.
+
+        Args:
+            marker: Fingerprint value.
+
+        Returns:
+            HTML comment string invisible in the rendered PR.
+        """
+        return f"<!-- {self.MARKER_PREFIX}{marker} -->"
+
+    def _extract_existing_markers(self, threads: list[dict]) -> set[str]:
+        """
+        Extracts all fingerprint markers present in existing PR threads.
+
+        Args:
+            threads: Threads as returned by :meth:`list_pr_threads`.
+
+        Returns:
+            Set of marker values found across every comment.
+        """
+        markers: set[str] = set()
+        for thread in threads:
+            for comment in thread.get("comments", []) or []:
+                content = comment.get("content", "") or ""
+                markers.update(self._MARKER_RE.findall(content))
+        return markers
+
     def _status_to_int(self, status: str) -> int:
         """Converts status string to API integer."""
         status_map = {

{code_review_ai_cli-2.2.3 → code_review_ai_cli-2.2.5}/tests/test_formatter.py

@@ -201,7 +201,8 @@ def test_format_post_results_summarizes_statuses() -> None:
     assert "Skipped at c.py" in rendered
     assert "Failed at b.py" in rendered
     assert "1 posted" in rendered
-    assert "2 failed" in rendered
+    assert "1 skipped" in rendered
+    assert "1 failed" in rendered
 
 
 def test_spinner_frame_rotates_frames() -> None:

{code_review_ai_cli-2.2.3 → code_review_ai_cli-2.2.5}/tests/test_llm_client.py

@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 
+import json
 import re
 import sys
 from pathlib import Path
@@ -606,7 +607,10 @@ def test_bedrock_boto3_success_and_error_paths(monkeypatch: pytest.MonkeyPatch)
     class FakeBedrockClient:
         """Stub Bedrock runtime client."""
 
+        last_converse_kwargs: dict[str, object] = {}
+
         def converse(self, **kwargs: object) -> dict:
+            FakeBedrockClient.last_converse_kwargs = kwargs
             return {"output": {"message": {"content": [{"text": "bedrock ok"}]}}}
 
     class FakeSession:
@@ -638,6 +642,12 @@ def test_bedrock_boto3_success_and_error_paths(monkeypatch: pytest.MonkeyPatch)
     assert client._call_bedrock("sys", "user") == "bedrock ok"
     assert client._call_bedrock_boto3("us-east-1", "sys", "user") == "bedrock ok"
 
+    client.config.temperature = 99
+    assert client._call_bedrock_boto3("us-east-1", "sys", "user") == "bedrock ok"
+    assert FakeBedrockClient.last_converse_kwargs["inferenceConfig"] == {
+        "maxTokens": 256,
+    }
+
     class BrokenSession(FakeSession):
         """Session that raises provider-side failures."""
 
@@ -689,8 +699,8 @@ def test_call_bedrock_routing_dispatches_correct_method(mocker) -> None:
 
 
 def test_call_bedrock_bearer_success_and_errors(monkeypatch: pytest.MonkeyPatch) -> None:
-    """_call_bedrock_bearer should use Bearer auth, URL-encode the model ARN and parse content."""
-    model_arn = "arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-3-sonnet"
+    """_call_bedrock_bearer should use the provider-agnostic Converse API."""
+    model_arn = "arn:aws:bedrock:us-east-1::foundation-model/openai.gpt-oss-120b-1:0"
     client = LLMClient(
         make_llm_config(
             llm_provider="bedrock",
@@ -703,15 +713,31 @@ def test_call_bedrock_bearer_success_and_errors(monkeypatch: pytest.MonkeyPatch)
     )
 
     # Success path: response parsed correctly, model ARN URL-encoded in URL
-    success_resp = FakeResponse(json_data={"content": [{"type": "text", "text": "bearer ok"}]})
+    success_resp = FakeResponse(
+        json_data={"output": {"message": {"content": [{"text": "bearer ok"}]}}}
+    )
     req_module = install_requests_raw(monkeypatch, success_resp)
     result = client._call_bedrock_bearer("us-east-1", "my-bearer-key", "sys", "user")
     assert result == "bearer ok"
     call = req_module._calls[0]
     assert "arn%3Aaws%3Abedrock" in call["url"]  # ':' encoded as %3A
-    assert "anthropic.claude-3-sonnet" in call["url"]
+    assert "openai.gpt-oss-120b-1%3A0" in call["url"]
+    assert call["url"].endswith("/converse")
     assert call["headers"]["Authorization"] == "Bearer my-bearer-key"
     assert call["headers"]["Content-Type"] == "application/json"
+    payload = json.loads(call["data"])
+    assert "anthropic_version" not in payload
+    assert payload == {
+        "system": [{"text": "sys"}],
+        "messages": [{"role": "user", "content": [{"text": "user"}]}],
+        "inferenceConfig": {"temperature": 0.2, "maxTokens": 256},
+    }
+
+    client.config.temperature = 99
+    req_module = install_requests_raw(monkeypatch, success_resp)
+    assert client._call_bedrock_bearer("us-east-1", "my-bearer-key", "sys", "user") == "bearer ok"
+    sentinel_payload = json.loads(req_module._calls[0]["data"])
+    assert sentinel_payload["inferenceConfig"] == {"maxTokens": 256}
 
     # 401 → specific authentication error message
     install_requests_raw(monkeypatch, FakeResponse(status_code=401))
@@ -724,12 +750,12 @@ def test_call_bedrock_bearer_success_and_errors(monkeypatch: pytest.MonkeyPatch)
         client._call_bedrock_bearer("us-east-1", "my-bearer-key", "sys", "user")
 
     # Empty content list → Unexpected response error
-    install_requests_raw(monkeypatch, FakeResponse(json_data={"content": []}))
+    install_requests_raw(monkeypatch, FakeResponse(json_data={"output": {"message": {"content": []}}}))
     with pytest.raises(LLMError, match="Unexpected Bedrock response"):
         client._call_bedrock_bearer("us-east-1", "my-bearer-key", "sys", "user")
 
     # Content items with no text type → Unexpected response error
-    install_requests_raw(monkeypatch, FakeResponse(json_data={"content": [{"type": "image", "data": "..."}]}))
+    install_requests_raw(monkeypatch, FakeResponse(json_data={"output": {"message": {"content": [{"image": {}}]}}}))
     with pytest.raises(LLMError, match="Unexpected Bedrock response"):
         client._call_bedrock_bearer("us-east-1", "my-bearer-key", "sys", "user")
 
@@ -741,18 +767,20 @@ def test_call_bedrock_bearer_success_and_errors(monkeypatch: pytest.MonkeyPatch)
 
 
 def test_call_bedrock_sigv4_success_and_errors(monkeypatch: pytest.MonkeyPatch) -> None:
-    """_call_bedrock_sigv4 should add SigV4 headers and parse content correctly."""
+    """_call_bedrock_sigv4 should use Converse with correctly signed requests."""
     client = LLMClient(
         make_llm_config(
             llm_provider="bedrock",
             api_key="",
-            model="anthropic.claude-3-sonnet",
+            model="openai.gpt-oss-120b-1:0",
             bedrock_region="us-east-1",
             bedrock_access_key_id="AKID",
             bedrock_secret_access_key="secret",
         )
     )
-    success_resp = FakeResponse(json_data={"content": [{"type": "text", "text": "sigv4 ok"}]})
+    success_resp = FakeResponse(
+        json_data={"output": {"message": {"content": [{"text": "sigv4 ok"}]}}}
+    )
 
     # Success path: SigV4 headers present in request
     req_module = install_requests_raw(monkeypatch, success_resp)
@@ -763,6 +791,16 @@ def test_call_bedrock_sigv4_success_and_errors(monkeypatch: pytest.MonkeyPatch)
     assert "x-amz-date" in call["headers"]
     assert "x-amz-content-sha256" in call["headers"]
     assert "x-amz-security-token" not in call["headers"]
+    assert call["url"].endswith("/converse")
+    payload = json.loads(call["data"])
+    assert "anthropic_version" not in payload
+    assert payload["inferenceConfig"] == {"temperature": 0.2, "maxTokens": 256}
+
+    client.config.temperature = 99
+    req_module = install_requests_raw(monkeypatch, success_resp)
+    assert client._call_bedrock_sigv4("us-east-1", "AKID", "secret", "", "sys", "user") == "sigv4 ok"
+    sentinel_payload = json.loads(req_module._calls[0]["data"])
+    assert sentinel_payload["inferenceConfig"] == {"maxTokens": 256}
 
     # Session token is forwarded as x-amz-security-token
     req_module = install_requests_raw(monkeypatch, success_resp)
@@ -782,7 +820,7 @@ def test_call_bedrock_sigv4_success_and_errors(monkeypatch: pytest.MonkeyPatch)
         client._call_bedrock_sigv4("us-east-1", "AKID", "secret", "", "sys", "user")
 
     # Empty content → Unexpected response error
-    install_requests_raw(monkeypatch, FakeResponse(json_data={"content": []}))
+    install_requests_raw(monkeypatch, FakeResponse(json_data={"output": {"message": {"content": []}}}))
     with pytest.raises(LLMError, match="Unexpected Bedrock response"):
         client._call_bedrock_sigv4("us-east-1", "AKID", "secret", "", "sys", "user")
 

{code_review_ai_cli-2.2.3 → code_review_ai_cli-2.2.5}/tests/test_tfs_client.py

@@ -693,6 +693,7 @@ def test_post_inline_comment_requires_iterations(mocker) -> None:
 def test_post_review_comments_formats_and_routes_comments(mocker) -> None:
     """It should route inline and general comments and collect failures."""
     client = TFSClient(make_tfs_config())
+    mocker.patch("src.tfs_client.TFSClient.list_pr_threads", return_value=[])
     formatter = mocker.patch("src.tfs_client.TFSClient._format_review_comment", side_effect=lambda comment: f"TEXT:{comment['comment']}")
     inline = mocker.patch("src.tfs_client.TFSClient.post_inline_comment", return_value={"id": 1})
     general = mocker.patch("src.tfs_client.TFSClient.post_general_comment", side_effect=[{"id": 2}, TFSError("boom")])
@@ -715,6 +716,116 @@ def test_post_review_comments_formats_and_routes_comments(mocker) -> None:
     assert results[2]["success"] is False
 
 
+def test_list_pr_threads_returns_value_list(mocker) -> None:
+    """It should GET the PR threads endpoint and return the value list."""
+    client = TFSClient(make_tfs_config())
+    get_mock = mocker.patch(
+        "src.tfs_client.TFSClient._get",
+        return_value={"value": [{"id": 1}, {"id": 2}]},
+    )
+
+    threads = client.list_pr_threads("repo-a", 7)
+
+    assert threads == [{"id": 1}, {"id": 2}]
+    path = get_mock.call_args.args[0]
+    assert path == "git/repositories/repo-a/pullrequests/7/threads"
+
+
+def test_comment_marker_is_stable_and_content_sensitive() -> None:
+    """It should produce a stable marker per location, ignoring comment text."""
+    client = TFSClient(make_tfs_config())
+    base = {"file": "src/app.py", "line": 3, "type": "bug", "comment": "x"}
+
+    assert client._comment_marker(base) == client._comment_marker(dict(base))
+    # Comment text is not part of the fingerprint.
+    assert client._comment_marker(base) == client._comment_marker(
+        {**base, "comment": "y"}
+    )
+    assert client._comment_marker(base) != client._comment_marker(
+        {**base, "line": 4}
+    )
+    assert client._comment_marker(base) != client._comment_marker(
+        {**base, "type": "security"}
+    )
+
+
+def test_extract_existing_markers_reads_all_threads() -> None:
+    """It should extract every fingerprint present in thread comments."""
+    client = TFSClient(make_tfs_config())
+    threads = [
+        {"comments": [{"content": "hi <!-- ai-review:abc123 -->"}]},
+        {"comments": [
+            {"content": "no marker here"},
+            {"content": "<!-- ai-review:summary -->"},
+        ]},
+    ]
+
+    assert client._extract_existing_markers(threads) == {"abc123", "summary"}
+
+
+def test_post_review_comments_skips_existing_and_dedupes_batch(mocker) -> None:
+    """It should skip already posted markers and dedupe within one batch."""
+    client = TFSClient(make_tfs_config())
+    duplicate = {"file": "src/app.py", "line": 3, "type": "bug", "comment": "dup"}
+    existing_marker = client._comment_marker(duplicate)
+    mocker.patch(
+        "src.tfs_client.TFSClient.list_pr_threads",
+        return_value=[{"comments": [
+            {"content": client._marker_html(existing_marker)}
+        ]}],
+    )
+    inline = mocker.patch(
+        "src.tfs_client.TFSClient.post_inline_comment", return_value={"id": 9}
+    )
+
+    new_comment = {"file": "src/app.py", "line": 5, "type": "bug", "comment": "new"}
+    results = client.post_review_comments(
+        "repo-a",
+        1,
+        [duplicate, new_comment, dict(new_comment)],
+    )
+
+    # First is skipped (already exists), second posted, third skipped (batch dedup).
+    assert results[0]["skipped"] is True
+    assert results[1]["success"] is True
+    assert results[2]["skipped"] is True
+    inline.assert_called_once()
+    posted_text = inline.call_args.args[4]
+    assert client._marker_html(client._comment_marker(new_comment)) in posted_text
+
+
+def test_post_general_comment_dedup_marker_skips_when_present(mocker) -> None:
+    """It should skip general comments whose dedup marker already exists."""
+    client = TFSClient(make_tfs_config())
+    post_mock = mocker.patch("src.tfs_client.TFSClient._post", return_value={"id": 5})
+    mocker.patch(
+        "src.tfs_client.TFSClient.list_pr_threads",
+        return_value=[{"comments": [{"content": "<!-- ai-review:summary -->"}]}],
+    )
+
+    result = client.post_general_comment(
+        "repo-a", 1, "summary body", dedup_marker="summary"
+    )
+
+    assert result["skipped"] is True
+    post_mock.assert_not_called()
+
+
+def test_post_general_comment_dedup_marker_posts_when_absent(mocker) -> None:
+    """It should append the marker and post when it is not already present."""
+    client = TFSClient(make_tfs_config())
+    post_mock = mocker.patch("src.tfs_client.TFSClient._post", return_value={"id": 5})
+    mocker.patch("src.tfs_client.TFSClient.list_pr_threads", return_value=[])
+
+    result = client.post_general_comment(
+        "repo-a", 1, "summary body", dedup_marker="summary"
+    )
+
+    assert result == {"id": 5}
+    _, payload = post_mock.call_args.args[:2]
+    assert "<!-- ai-review:summary -->" in payload["comments"][0]["content"]
+
+
 def test_repository_helpers_and_status_formatting(mocker) -> None:
     """It should format review comments and resolve repositories by name."""
     client = TFSClient(make_tfs_config())