code-review-ai-cli 2.2.4__py3-none-any.whl → 2.2.6__py3-none-any.whl

{code_review_ai_cli-2.2.4.dist-info → code_review_ai_cli-2.2.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-review-ai-cli
-Version: 2.2.4
+Version: 2.2.6
 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
@@ -19,6 +19,8 @@ Requires-Dist: requests>=2.28.0
 Requires-Dist: PyYAML>=6.0
 Requires-Dist: litellm>=1.40.0
 Requires-Dist: tiktoken>=0.7.0
+Requires-Dist: tree-sitter<0.22,>=0.20
+Requires-Dist: tree-sitter-languages>=1.10.2
 Provides-Extra: bedrock
 Requires-Dist: boto3>=1.34.0; extra == "bedrock"
 Provides-Extra: openai
@@ -27,8 +29,6 @@ Provides-Extra: gemini
 Requires-Dist: google-generativeai>=0.3.0; extra == "gemini"
 Provides-Extra: claude
 Requires-Dist: anthropic>=0.18.0; extra == "claude"
-Provides-Extra: tree-sitter
-Requires-Dist: tree-sitter-languages>=1.10.2; extra == "tree-sitter"
 Provides-Extra: all
 Requires-Dist: boto3>=1.34.0; extra == "all"
 Requires-Dist: litellm>=1.40.0; extra == "all"
@@ -36,7 +36,6 @@ Requires-Dist: tiktoken>=0.7.0; extra == "all"
 Requires-Dist: openai>=1.0.0; extra == "all"
 Requires-Dist: google-generativeai>=0.3.0; extra == "all"
 Requires-Dist: anthropic>=0.18.0; extra == "all"
-Requires-Dist: tree-sitter-languages>=1.10.2; extra == "all"
 Provides-Extra: dev
 Requires-Dist: pytest>=8.3.0; extra == "dev"
 Requires-Dist: pytest-cov>=5.0.0; extra == "dev"

code_review_ai_cli-2.2.6.dist-info/RECORD

@@ -0,0 +1,17 @@
+src/__init__.py,sha256=BNfzb1HoMlgLc9MNEzc8Ne7USol7NHRUcMn7ISQ41sY,259
+src/ai_review.py,sha256=Wfeo72uTsjuoKMW5ToqFi6edfVIWTMgqPIbv9_W8Z-Y,34482
+src/config.py,sha256=GFqGfjnhjY0O6EiDTsFFCM3qvSCVZMPd3IbmWd4SOWk,16419
+src/context_extractor.py,sha256=SyuTtau1eIVmjOkqmV_8ijawqDiGK_M7G9May99oBAo,20928
+src/formatter.py,sha256=68kz1U6tMndLcmtJRImN4jAIpxXtog3cKtiJ-zc3S0M,19027
+src/git_utils.py,sha256=sJPV-NpSx0up-KDvFK1Pn73mvGdSNiCqTjEj6I8kzpM,10218
+src/llm_client.py,sha256=dVVkJ1glf1K-I_oWZ-qxMABaBLQ4gq4blOiM5lvFEp0,54393
+src/prompt_utils.py,sha256=FnWgHQ7UW8dEKW-4R7ngpL6DNqbW7xFEKi5JsZ7348E,2045
+src/tfs_client.py,sha256=Y7MIu5dutZ2J223yLJJPai3pbux5dnB-MoK_SQe-08I,37459
+src/token_estimator.py,sha256=4_4TXhefaNi7KHomwhhWbt7GB6KfubCQVBEbD3YoK5Q,3192
+src/prompts/config.yaml.template,sha256=p5ZolxDPmht_RXaS1iLcPqpK1zle20i5eAnWeKuKT2U,4878
+src/prompts/review_prompt.md.template,sha256=OWlSqCIkJA6Q8fUuNNrI61B7YyfrRhDLy7nUfw46rJQ,2903
+code_review_ai_cli-2.2.6.dist-info/METADATA,sha256=VQr3a3CZ9eIhkvjJ8Bt_Y3k3SNJRAoNlsIwvCkRiNYY,4966
+code_review_ai_cli-2.2.6.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+code_review_ai_cli-2.2.6.dist-info/entry_points.txt,sha256=hzKqoXIQVpiCe4H-XV0DZcKwJY6Uj3M-WvBMEQtwr3o,49
+code_review_ai_cli-2.2.6.dist-info/top_level.txt,sha256=74rtVfumQlgAPzR5_2CgYN24MB0XARCg0t-gzk6gTrM,4
+code_review_ai_cli-2.2.6.dist-info/RECORD,,

src/config.py

@@ -92,8 +92,8 @@ class ReviewConfig:
     review_scope: str = "diff_only"         # "diff_only" | "full_code"
     max_diff_files: int = 50                 # Max diff files sent to LLM
     max_diff_lines: int = 2000              # Max diff lines
-    max_scope_blocks: int = 3               # Max changed blocks for Enclosing Scopes strategy
-    max_scope_lines: int = 250              # Max lines in a single scope block before fallback to file_skeleton
+    max_scope_blocks: int = 8               # Max changed blocks for Enclosing Scopes strategy
+    max_scope_lines: int = 250              # Max lines in a scope before Adaptive Diff fallback
     adaptive_context_lines: int = 10        # Context lines for Adaptive Diff fallback
     custom_prompt_file: str = "review_prompt.md"  # Markdown file with extra rules/context
     file_extensions_filter: list = field(default_factory=list)  # File extensions to include (empty = all)

src/context_extractor.py

@@ -7,20 +7,19 @@ Context Extractor Module - AI Code Review
 Provides AST-based context extraction for diff payloads sent to the LLM.
 
 Strategy selection per file:
-  - SQL files            → full SQL statement containing the changed line(s)
-  - ≤ ``MAX_SCOPE_BLOCKS`` changed logical blocks → Enclosing Scopes (Scenario A)
-  - > ``MAX_SCOPE_BLOCKS`` changed logical blocks → File Skeleton (Scenario B)
-  - Tree-sitter unavailable / language unsupported → Adaptive Diff fallback
+  - AST scopes within the configured limits → Enclosing Scopes
+  - Tree-sitter unavailable, unsupported language, parse failure, or scopes
+    outside the configured limits → Adaptive Diff fallback
 
 Output is always wrapped in XML tags so the LLM can distinguish code context
 from the actual diff:
 
   ``<enclosing_scopes file="src/auth.py">...</enclosing_scopes>``
-  ``<file_skeleton    file="src/module.py">...</file_skeleton>``
   ``<adaptive_diff    file="src/other.py">...</adaptive_diff>``
 
-Tree-sitter is an *optional* dependency.  If ``tree-sitter-languages`` is not
-installed the module automatically falls back to :func:`_build_adaptive_diff`.
+Tree-sitter is installed as a core dependency. The availability probe remains
+defensive: reduced or broken environments fall back to
+:func:`_build_adaptive_diff` instead of failing the review.
 """
 
 from __future__ import annotations
@@ -68,13 +67,12 @@ except Exception:  # pragma: no cover — optional dependency
 # Constants
 # ---------------------------------------------------------------------------
 
-#: Maximum number of distinct logical blocks that triggers Scenario A
-#: (Enclosing Scopes).  When more blocks are detected Scenario B (File
-#: Skeleton) is used instead.
-MAX_SCOPE_BLOCKS: int = 3
+#: Maximum number of distinct logical blocks included as Enclosing Scopes.
+#: When more blocks are detected the extractor uses Adaptive Diff instead.
+MAX_SCOPE_BLOCKS: int = 8
 
 #: Maximum number of lines in a single enclosing scope.  When a scope
-#: exceeds this limit the strategy falls back to File Skeleton to avoid
+#: exceeds this limit the strategy falls back to Adaptive Diff to avoid
 #: sending large class bodies to the LLM.
 MAX_SCOPE_LINES: int = 250
 
@@ -370,147 +368,76 @@ def _extract_enclosing_scopes_ts(
     return scopes
 
 
-def _format_scope_block(scope: ScopeInfo) -> str:
-    """Render a :class:`ScopeInfo` with absolute 1-based line numbers."""
-    lines: list[str] = []
-    for offset, src_line in enumerate(scope.source_lines):
-        abs_line = scope.start_line + offset
-        lines.append(f"{abs_line:4d}: {src_line}")
-    return "\n".join(lines)
-
+def _non_whitespace_changed_lines(content: str, changed_lines: list[int]) -> list[int]:
+    """Return changed lines that contain meaningful code in the new file.
 
-# ---------------------------------------------------------------------------
-# File Skeleton helpers
-# ---------------------------------------------------------------------------
-
-#: Regex patterns used to identify structural lines in each language.
-_SKELETON_PATTERNS: dict[str, list[str]] = {
-    "python": [
-        r"^\s*(?:import|from)\s+",           # imports
-        r"^\s*(?:def|async\s+def|class)\s+", # definitions
-        r"^\s*@\w",                           # decorators
-    ],
-    "javascript": [
-        r"^\s*(?:import|export|require)\s*",
-        r"^\s*(?:function|class|const|let|var)\s+\w+\s*(?:=\s*(?:function|\(|\()|\()",
-        r"^\s*(?:async\s+function|export\s+(?:default\s+)?(?:function|class))",
-    ],
-    "typescript": [
-        r"^\s*(?:import|export|require)\s*",
-        r"^\s*(?:function|class|const|let|var|interface|type|enum|abstract)\s+\w+",
-        r"^\s*(?:async\s+function|export\s+(?:default\s+)?(?:function|class|interface))",
-    ],
-    "tsx": [
-        r"^\s*(?:import|export|require)\s*",
-        r"^\s*(?:function|class|const|let|var|interface|type|enum|abstract)\s+\w+",
-    ],
-    "c_sharp": [
-        r"^\s*(?:using)\s+",
-        r"^\s*(?:namespace|public|private|protected|internal|static|sealed|abstract|partial|override|virtual)\s+",
-        r"^\s*(?:\[[\w\.\(\)\"]+\])",        # attributes
-    ],
-    "java": [
-        r"^\s*(?:import|package)\s+",
-        r"^\s*(?:public|private|protected|static|final|abstract|synchronized|@)\s*",
-    ],
-    "sql": [],  # SQL skeleton falls back to individual statements
-}
-
-# Body-start patterns (lines after which we can insert "...")
-_BODY_START: dict[str, list[str]] = {
-    "python":     [r":\s*$"],
-    "javascript": [r"\{\s*$"],
-    "typescript": [r"\{\s*$"],
-    "tsx":        [r"\{\s*$"],
-    "c_sharp":    [r"\{\s*$"],
-    "java":       [r"\{\s*$"],
-    "sql":        [],
-}
-
-
-def _build_file_skeleton(
-    content: str,
-    changed_lines: list[int],
-    lang: str,
-) -> str:
-    """Build a file skeleton: structural lines + changed blocks + ``...`` placeholders.
-
-    The skeleton includes:
-    - All structural/declaration lines (imports, signatures, class headers)
-    - Full content of lines inside changed regions (± ADAPTIVE_CONTEXT_LINES)
-    - ``...`` for bodies of unchanged functions/methods
-
-    Args:
-        content: Full source file content.
-        changed_lines: 1-based line numbers that were changed.
-        lang: Tree-sitter language name for pattern selection.
-
-    Returns:
-        Formatted skeleton string with 1-based line numbers.
+    Whitespace-only additions must not influence AST scope selection. For
+    example, a blank line immediately after a method belongs to its containing
+    class and would otherwise cause the entire class to be selected.
     """
     all_lines = content.splitlines()
-    total = len(all_lines)
-
-    if not all_lines:
-        return ""
-
-    # Build set of "always include" lines (context around changes)
-    always: set[int] = set()
-    for ln in changed_lines:
-        lo = max(1, ln - ADAPTIVE_CONTEXT_LINES)
-        hi = min(total, ln + ADAPTIVE_CONTEXT_LINES)
-        always.update(range(lo, hi + 1))
-
-    # Structural patterns for this language
-    struct_patterns = [re.compile(p) for p in _SKELETON_PATTERNS.get(lang, [])]
-
-    result_lines: list[str] = []
-    skipping = False
-    prev_shown: Optional[int] = None
-
-    for idx, src in enumerate(all_lines, start=1):
-        is_structural = any(p.search(src) for p in struct_patterns)
-        in_changed = idx in always
-
-        if in_changed or is_structural:
-            if skipping and prev_shown is not None:
-                result_lines.append("      ...")
-            skipping = False
-            result_lines.append(f"{idx:4d}: {src}")
-            prev_shown = idx
-        else:
-            skipping = True
-
-    if skipping:
-        result_lines.append("      ...")
+    return [
+        line_number
+        for line_number in changed_lines
+        if 1 <= line_number <= len(all_lines)
+        and all_lines[line_number - 1].strip()
+    ]
 
-    return "\n".join(result_lines)
 
-
-# ---------------------------------------------------------------------------
-# SQL-specific extraction
-# ---------------------------------------------------------------------------
-
-
-def _extract_sql_statement(
-    content: str,
+def _remove_redundant_ancestor_scopes(
+    scopes: list[ScopeInfo],
     changed_lines: list[int],
-    lang: str,
 ) -> list[ScopeInfo]:
-    """Find the SQL statement(s) covering each changed line via Tree-sitter.
+    """Drop ancestor scopes whose changed lines are covered by child scopes.
 
-    Args:
-        content: Full SQL file content.
-        changed_lines: 1-based line numbers that were changed.
-        lang: Always ``"sql"`` for this path.
+    An ancestor is retained when it contains at least one meaningful changed
+    line outside every selected descendant. This avoids duplicate class and
+    method bodies without losing class-level changes.
+    """
+    retained: list[ScopeInfo] = []
+
+    for scope in scopes:
+        descendants = [
+            candidate
+            for candidate in scopes
+            if candidate is not scope
+            and scope.start_line <= candidate.start_line
+            and candidate.end_line <= scope.end_line
+            and (
+                scope.start_line < candidate.start_line
+                or candidate.end_line < scope.end_line
+            )
+        ]
+        scope_changes = [
+            line_number
+            for line_number in changed_lines
+            if scope.start_line <= line_number <= scope.end_line
+        ]
+        changes_covered_by_descendants = (
+            bool(scope_changes)
+            and bool(descendants)
+            and all(
+                any(
+                    child.start_line <= line_number <= child.end_line
+                    for child in descendants
+                )
+                for line_number in scope_changes
+            )
+        )
 
-    Returns:
-        List of :class:`ScopeInfo` for each affected SQL statement.
+        if not changes_covered_by_descendants:
+            retained.append(scope)
 
-    Raises:
-        Exception: On Tree-sitter parse failure (caller activates fallback).
-    """
-    return _extract_enclosing_scopes_ts(content, changed_lines, lang)
+    return retained
+
+
+def _format_scope_block(scope: ScopeInfo) -> str:
+    """Render a :class:`ScopeInfo` with absolute 1-based line numbers."""
+    lines: list[str] = []
+    for offset, src_line in enumerate(scope.source_lines):
+        abs_line = scope.start_line + offset
+        lines.append(f"{abs_line:4d}: {src_line}")
+    return "\n".join(lines)
 
 
 # ---------------------------------------------------------------------------
@@ -533,9 +460,10 @@ class ContextExtractor:
     The returned *xml_block* is ready to be embedded in the LLM user message.
 
     Attributes:
-        max_scope_blocks: Threshold for Scenario A vs Scenario B selection.
+        max_scope_blocks: Maximum number of AST scopes before falling back to
+            adaptive_diff.
         max_scope_lines: Maximum lines per scope block before falling back to
-            file_skeleton (avoids sending entire large classes to the LLM).
+            adaptive_diff (avoids sending entire large classes to the LLM).
         adaptive_context_lines: Lines of context for the fallback strategy.
     """
 
@@ -565,9 +493,8 @@ class ContextExtractor:
 
         1. If Tree-sitter is unavailable → ``adaptive_diff``
         2. If the language is not supported → ``adaptive_diff``
-        3. If the language is SQL → ``sql_statement`` (falls back on failure)
-        4. If ≤ ``max_scope_blocks`` distinct scopes found → ``enclosing_scopes``
-        5. Otherwise → ``file_skeleton``
+        3. If the extracted scopes fit the configured limits → ``enclosing_scopes``
+        4. Otherwise → ``adaptive_diff``
 
         Args:
             file_path: Path (or name) of the file being reviewed.
@@ -576,9 +503,8 @@ class ContextExtractor:
 
         Returns:
             A tuple ``(strategy, xml_block)`` where *strategy* is one of
-            ``"enclosing_scopes"``, ``"file_skeleton"``, ``"sql_statement"``,
-            or ``"adaptive_diff"``, and *xml_block* is the XML-tagged string
-            ready for the LLM payload.
+            ``"enclosing_scopes"`` or ``"adaptive_diff"``, and *xml_block*
+            is the XML-tagged string ready for the LLM payload.
         """
         if not changed_lines:
             return "adaptive_diff", ""
@@ -592,24 +518,18 @@ class ContextExtractor:
             return self._adaptive(file_path, new_content, changed_lines)
 
         # ------------------------------------------------------------------
-        # SQL path
+        # Generic AST path
         # ------------------------------------------------------------------
-        if lang == "sql":
-            try:
-                scopes = _extract_sql_statement(new_content, changed_lines, lang)
-                if scopes:
-                    return self._format_enclosing_scopes(
-                        file_path, scopes, strategy="sql_statement"
-                    )
-            except Exception:
-                pass
+        ast_changed_lines = _non_whitespace_changed_lines(new_content, changed_lines)
+        if not ast_changed_lines:
             return self._adaptive(file_path, new_content, changed_lines)
 
-        # ------------------------------------------------------------------
-        # Generic AST path
-        # ------------------------------------------------------------------
         try:
-            scopes = _extract_enclosing_scopes_ts(new_content, changed_lines, lang)
+            scopes = _extract_enclosing_scopes_ts(
+                new_content,
+                ast_changed_lines,
+                lang,
+            )
         except Exception:
             return self._adaptive(file_path, new_content, changed_lines)
 
@@ -617,29 +537,17 @@ class ContextExtractor:
             # No enclosing scope found (top-level code) → adaptive diff
             return self._adaptive(file_path, new_content, changed_lines)
 
-        if len(scopes) <= self.max_scope_blocks:
-            # Check if any single scope is too large — if so, fall back to
-            # file_skeleton to avoid sending a 900-line class body to the LLM.
-            oversized = any(
-                (s.end_line - s.start_line) > self.max_scope_lines
-                for s in scopes
-            )
-            if not oversized:
-                # Scenario A: Enclosing Scopes
-                return self._format_enclosing_scopes(file_path, scopes)
+        scopes = _remove_redundant_ancestor_scopes(scopes, ast_changed_lines)
 
-        # Scenario B: File Skeleton
-        try:
-            skeleton = _build_file_skeleton(new_content, changed_lines, lang)
-        except Exception:
+        too_many_scopes = len(scopes) > self.max_scope_blocks
+        oversized_scope = any(
+            (s.end_line - s.start_line + 1) > self.max_scope_lines
+            for s in scopes
+        )
+        if too_many_scopes or oversized_scope:
             return self._adaptive(file_path, new_content, changed_lines)
 
-        xml = (
-            f'<file_skeleton file="{file_path}">\n'
-            f"{skeleton}\n"
-            f"</file_skeleton>"
-        )
-        return "file_skeleton", xml
+        return self._format_enclosing_scopes(file_path, scopes)
 
     # ------------------------------------------------------------------
     # Internal formatters
@@ -666,7 +574,6 @@ class ContextExtractor:
         self,
         file_path: str,
         scopes: list[ScopeInfo],
-        strategy: str = "enclosing_scopes",
     ) -> tuple[str, str]:
         """Render a list of :class:`ScopeInfo` into an XML block."""
         parts: list[str] = []
@@ -679,13 +586,12 @@ class ContextExtractor:
             parts.append(_format_scope_block(scope))
 
         body = "\n".join(parts)
-        tag = "enclosing_scopes" if strategy == "enclosing_scopes" else strategy
         xml = (
-            f'<{tag} file="{file_path}">\n'
+            f'<enclosing_scopes file="{file_path}">\n'
             f"{body}\n"
-            f"</{tag}>"
+            f"</enclosing_scopes>"
         )
-        return strategy, xml
+        return "enclosing_scopes", xml
 
     # ------------------------------------------------------------------
     # Utility: extract changed lines from a diff hunk for one file

src/git_utils.py

@@ -100,7 +100,7 @@ class GitUtils:
             - ``@@ ... @@``
             - ``+ <content>`` (added lines)
             - `` <content>`` (context lines — unchanged surrounding code)
-            - Lines inside XML context blocks (``<enclosing_scopes>``, ``<file_skeleton>``, etc.)
+            - Lines inside XML context blocks (``<enclosing_scopes>`` or ``<adaptive_diff>``)
 
         Lines removed:
             - ``- <content>`` (deleted lines)
@@ -114,8 +114,8 @@ class GitUtils:
         """
         result = []
         in_xml_block = False
-        _xml_start_tags = ("<enclosing_scopes", "<file_skeleton", "<adaptive_diff", "<sql_statement")
-        _xml_end_tags = ("</enclosing_scopes>", "</file_skeleton>", "</adaptive_diff>", "</sql_statement>")
+        _xml_start_tags = ("<enclosing_scopes", "<adaptive_diff")
+        _xml_end_tags = ("</enclosing_scopes>", "</adaptive_diff>")
 
         for line in diff.split("\n"):
             if any(line.startswith(tag) for tag in _xml_start_tags):
@@ -204,7 +204,7 @@ class GitUtils:
 
     def truncate_diff_per_file(self, diff: str, max_lines: int = 2000) -> tuple[str, bool]:
         """
-        Truncates the diff per file if it exceeds the maximum lines per section.
+        Truncates diff lines per file while preserving complete XML context blocks.
         Falls back to global truncation if no file sections are present.
         
         Returns:
@@ -227,18 +227,30 @@ class GitUtils:
         truncated_any = False
         output_sections: list[str] = []
         for section in sections:
-            if len(section) <= max_lines:
+            xml_start = next(
+                (
+                    index
+                    for index, line in enumerate(section)
+                    if line.startswith(("<enclosing_scopes", "<adaptive_diff"))
+                ),
+                len(section),
+            )
+            diff_lines = section[:xml_start]
+            context_lines = section[xml_start:]
+
+            if len(diff_lines) <= max_lines:
                 output_sections.append("\n".join(section))
                 continue
 
             truncated_any = True
-            omitted = len(section) - max_lines
-            part = "\n".join(section[:max_lines])
-            part += (
-                f"\n... [TRUNCATED IN THIS FILE: {omitted} lines omitted. "
-                f"Original section: {len(section)} lines] ..."
+            omitted = len(diff_lines) - max_lines
+            truncated_section = diff_lines[:max_lines]
+            truncated_section.append(
+                f"... [TRUNCATED IN THIS FILE: {omitted} diff lines omitted. "
+                f"Original diff section: {len(diff_lines)} lines] ..."
             )
-            output_sections.append(part)
+            truncated_section.extend(context_lines)
+            output_sections.append("\n".join(truncated_section))
 
         return "\n".join(output_sections), truncated_any
 

src/llm_client.py

@@ -28,6 +28,26 @@ class LLMError(Exception):
     """Exception for LLM communication errors."""
     pass
 
+
+def _normalize_prompt_spacing(text: str) -> str:
+    """Collapse repeated blank lines while preserving one between sections."""
+    normalized_lines: list[str] = []
+    blank_pending = False
+
+    for line in text.splitlines():
+        if not line.strip():
+            if normalized_lines:
+                blank_pending = True
+            continue
+
+        if blank_pending:
+            normalized_lines.append("")
+            blank_pending = False
+        normalized_lines.append(line)
+
+    return "\n".join(normalized_lines)
+
+
 # ---------------------------------------------------------------------------
 # System Prompts
 # ---------------------------------------------------------------------------
@@ -43,32 +63,17 @@ class LLMError(Exception):
 #     fallback to "detailed" when the key is not recognised.
 SYSTEM_PROMPTS = {
     "detailed": (
-        "You are an experienced Senior Code Reviewer. Analyze the provided code and return only inline comments.\n\n"
-        "Output format — for each issue found, output exactly:\n"
-        "- Line <line_number>: <issue description>\n\n"
-        "Rules:\n"
-        "- Report ONLY specific issues tied to a concrete line or block of changed code.\n"
-        "- Do NOT produce summary sections (e.g. 'Potential Bugs', 'Security Overview').\n"
-        "- Do NOT produce introductory or closing paragraphs.\n"
-        "- If no issues are found, output only: No issues found.\n"
-        "- Be specific, actionable, and concise."
+        "You are an AI Agente code reviewer. Identify concrete bugs, security risks, "
+        "performance problems, and maintainability issues introduced by the change. "
+        "Report only actionable findings tied to changed code; be specific and concise."
     ),
     "security": (
-        "You are an application security. Analyze the "
-        "provided code diff with EXCLUSIVE focus on security.\n\n"
-        "Look for:\n"
-        "- SQL Injection\n"
-        "- Cross-Site Scripting (XSS)\n"
-        "- Cross-Site Request Forgery (CSRF)\n"
-        "- Hardcoded credentials or exposed secrets\n"
-        "- Authentication/authorization vulnerabilities\n"
-        "- Insecure deserialization\n"
-        "- Path traversal\n"
-        "- Command injection\n"
-        "- Dependencies with known vulnerabilities\n"
-        "- Logging of sensitive information\n"
-        "- Insecure configurations\n\n"
-        "Provide fix recommendations for each issue."
+        "You are an AI Agente application security reviewer. Identify actionable security vulnerabilities "
+        "introduced by the change, including injection, XSS, CSRF, exposed secrets, broken "
+        "authentication or authorization, insecure deserialization, path traversal, vulnerable "
+        "dependencies, sensitive-data logging, and insecure configuration. Consider other "
+        "security risks when relevant. Report only findings tied to changed code and include "
+        "a concise fix recommendation for each."
     ),
 }
 
@@ -91,15 +96,20 @@ PR_COMMENT_PROMPT = (
     'something like "No issues found."\n'
     '- "comments": an array of objects, one per issue found, with:\n'
     '  - "file": file path (e.g., "src/auth.py")\n'
-    '  - "line": line number in diff (integer, or 0 if general)\n'
+    '  - "line": positive absolute line number in the new file (integer)\n'
     '  - "type": issue type ("bug", "security", "performance", "style", "suggestion", "praise")\n'
     '  - "comment": direct description of the issue, with no greetings and no emojis\n'
-    '  - "suggestion": fix suggestion (optional, empty string if not applicable)\n'
-    '  - "reference": source or reference for the issue (e.g., "OWASP Top 10", "PEP 8", documentation '
-    'URL, standard or principle). Important: ALWAYS include a relevant reference.\n\n'
-    "In 'comment', use a short and objective tone. "
-    "Do not include intros like 'Hello' or 'As a senior reviewer'.\n"
-    "In 'reference', include a trusted source, standard or link to relevant documentation.\n\n"
+    '  - "suggestion": concise, concrete fix recommendation (string)\n'
+    '  - "reference": relevant trusted source, standard, or documentation URL; use an empty string '
+    'when no reliable reference applies\n\n'
+    "The summary is a brief narrative of the overall review, not a heading or a duplicate list "
+    "of comments. Use an empty comments array when no issues are found. Each comment must refer "
+    "to a specific actionable issue in changed code, and its line must be a positive absolute "
+    "line number from the new file. Every comment must include a concise, concrete fix "
+    "recommendation in 'suggestion'; do not leave it empty for an actionable issue. Use a short, "
+    "objective tone with no greetings or emojis. "
+    "Include a relevant trusted source in 'reference' when one applies; otherwise use an empty "
+    "string. Never invent a citation.\n\n"
     "Respond ONLY with a valid JSON object. Example:\n"
     '{\n'
     '  "summary": "Short narrative summary of the review...",\n'
@@ -120,14 +130,12 @@ PR_COMMENT_PROMPT = (
 def get_system_prompt(verbosity: str) -> str:
     """Returns the system prompt for the given verbosity level.
 
-    Selects a prompt from ``SYSTEM_PROMPTS`` keyed by *verbosity*. If the
+    Selects review-focus guidance from ``SYSTEM_PROMPTS`` keyed by *verbosity*. If the
     requested verbosity is not found, the function falls back to
     ``"detailed"``.
 
-    The ``"detailed"`` prompt instructs the LLM to return **only** inline
-    comments in the format ``- Line <n>: <description>``,
-    prohibiting summary sections and introductory/closing paragraphs.
-    When no issues are found the expected output is ``No issues found.``
+    The selected prompt controls review focus only. The PR JSON output contract
+    is defined separately by ``PR_COMMENT_PROMPT``.
 
     Args:
         verbosity: Review depth key — one of ``"detailed"``
@@ -145,21 +153,17 @@ def get_scope_guidance(review_scope: str, structured: bool = False) -> str:
 
     For ``diff_only`` scope, the instructions inform the LLM that:
 
-    * Added lines are prefixed with ``+`` and context lines (unchanged code)
-      have no prefix. Deleted lines are not included.
-    * An XML context block is provided for each changed file, containing
-      either:
+    * Added lines are prefixed with ``+``. Each hunk includes up to five
+      unchanged context lines before and after the changes, prefixed with a
+      single space. Deleted lines are not included.
+    * When source content is available, a changed file may include an XML
+      context block containing either:
 
       - ``<enclosing_scopes file="...">`` — the complete function(s) or
-        method(s) that enclose the changed lines (Scenario A, ≤3 blocks).
-      - ``<file_skeleton file="...">`` — a structural skeleton of the file
-        with unchanged function bodies replaced by ``...`` (Scenario B,
-        >3 blocks).
-      - ``<sql_statement file="...">`` — the full SQL statement containing
-        the changed lines.
+        methods/statements that enclose the changed lines.
       - ``<adaptive_diff file="...">`` — N lines of context around the
-        changed lines when Tree-sitter is unavailable or the language is
-        not supported.
+        changed lines when AST extraction is unavailable or exceeds its
+        configured limits.
 
     * Line numbers inside the XML blocks are **1-based absolute** line
       numbers from the new version of the file and should be used as the
@@ -193,13 +197,13 @@ def get_scope_guidance(review_scope: str, structured: bool = False) -> str:
     if structured:
         return (
             "Review scope: diff_only. "
-            "The <diff> block contains added lines (marked +) and surrounding context lines "
-            "(unchanged code, no prefix). Deleted lines were removed. "
-            "An XML context block is provided for each changed file: "
-            "<enclosing_scopes> contains the complete function(s)/method(s) enclosing the changes; "
-            "<file_skeleton> contains a structural skeleton for files with many spread changes; "
-            "<sql_statement> contains the full SQL statement for SQL files; "
-            "<adaptive_diff> contains surrounding context lines when AST parsing is unavailable. "
+            "The <diff> block contains added lines (prefixed with +) and up to five unchanged "
+            "context lines before and after each hunk (prefixed with a single space). "
+            "Deleted lines were removed. When source content is available, a changed file may "
+            "include an XML context block: "
+            "<enclosing_scopes> contains the complete AST scope(s) enclosing the changes; "
+            "<adaptive_diff> contains surrounding context lines when AST extraction is unavailable "
+            "or exceeds its configured limits. "
             "Line numbers inside XML context blocks are 1-based absolute line numbers from the new file. "
             "Use those line numbers as the authoritative reference when reporting issue positions. "
             "Focus your review EXCLUSIVELY on the changed lines (marked + in <diff>). "
@@ -210,10 +214,11 @@ def get_scope_guidance(review_scope: str, structured: bool = False) -> str:
 
     return (
         "Review scope: diff_only. "
-        "The <diff> block contains added lines (marked +) and surrounding context lines "
-        "(unchanged code, no prefix). Deleted lines were removed. "
-        "An XML context block is provided for each changed file "
-        "(<enclosing_scopes>, <file_skeleton>, <sql_statement>, or <adaptive_diff>) "
+        "The <diff> block contains added lines (prefixed with +) and up to five unchanged "
+        "context lines before and after each hunk (prefixed with a single space). "
+        "Deleted lines were removed. When source content is available, a changed file may "
+        "include an XML context block "
+        "(<enclosing_scopes> or <adaptive_diff>) "
         "as read-only structural background. "
         "Line numbers inside XML context blocks are 1-based absolute line numbers from the new file. "
         "Use those line numbers as the authoritative reference when reporting issue positions. "
@@ -263,7 +268,7 @@ def build_user_message(diff: str, files_summary: list[dict], context: str = "")
         parts.append("<context>\n" + "\n".join(context_inner) + "\n</context>")
 
     # --- Split diff lines from XML context blocks ---
-    # XML context blocks (enclosing_scopes, file_skeleton, etc.) are already
+    # XML context blocks (enclosing_scopes or adaptive_diff) are already
     # embedded inside the diff string by TFSClient._build_unified_diff_part.
     # We extract them here and render them separately so the LLM sees:
     #   <diff>  ... pure unified diff ...</diff>
@@ -275,14 +280,10 @@ def build_user_message(diff: str, files_summary: list[dict], context: str = "")
     _in_xml = False
     _xml_tags = (
         "<enclosing_scopes ",
-        "<file_skeleton ",
-        "<sql_statement ",
         "<adaptive_diff ",
     )
     _xml_close = (
         "</enclosing_scopes>",
-        "</file_skeleton>",
-        "</sql_statement>",
         "</adaptive_diff>",
     )
 
@@ -329,11 +330,12 @@ class LLMClient:
 
     def _dump_prompt_debug(self, system_prompt: str, user_message: str) -> None:
         """
-        Appends the full prompt/context sent to the LLM to a debug log file.
+        Writes the normalized prompt content sent to the LLM.
 
         Only active when ``config.debug_dump`` is enabled. The log may
         contain source code and PR content, so it must never be committed
-        to version control.
+        to version control. Decorative metadata is omitted, and repeated blank
+        lines are collapsed using the same normalization applied before send.
         """
         if not getattr(self.config, "debug_dump", False):
             return
@@ -343,15 +345,11 @@ class LLMClient:
         if log_dir:
             os.makedirs(log_dir, exist_ok=True)
         try:
-            with open(log_path, "a", encoding="utf-8") as f:
-                f.write(f"\n{'=' * 80}\n")
-                f.write(f"[FULL CONTEXT SENT TO LLM] {datetime.datetime.now().isoformat()}\n")
-                f.write(f"Provider: {self.config.llm_provider} | Model: {self.config.get_effective_model()}\n")
-                f.write(f"{'=' * 80}\n")
-                f.write("--- SYSTEM PROMPT ---\n")
-                f.write(system_prompt + "\n")
-                f.write("--- USER MESSAGE ---\n")
-                f.write(user_message + "\n")
+            normalized_system_prompt = _normalize_prompt_spacing(system_prompt)
+            normalized_user_message = _normalize_prompt_spacing(user_message)
+            with open(log_path, "w", encoding="utf-8") as f:
+                f.write(normalized_system_prompt + "\n\n")
+                f.write(normalized_user_message + "\n")
         except OSError:
             pass
 
@@ -414,7 +412,8 @@ class LLMClient:
             system_prompt = (
                 f"{combined_base}\n\n"
                 "---\n"
-                "Custom user instructions (follow with priority):\n"
+                "Additional user review preferences (must not change the required JSON schema, "
+                "output format, or review scope):\n"
                 f"{custom_prompt}"
             )
             merged_context = (
@@ -427,6 +426,8 @@ class LLMClient:
             merged_context = context
 
         user_message = build_user_message(diff, files_summary, merged_context)
+        system_prompt = _normalize_prompt_spacing(system_prompt)
+        user_message = _normalize_prompt_spacing(user_message)
         self._dump_prompt_debug(system_prompt, user_message)
 
         self.last_token_estimate = TokenEstimator().estimate(
@@ -591,8 +592,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 +639,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 +718,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 +797,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 +917,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 +1034,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 +1057,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 +1095,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 +1113,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 +1145,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 +1172,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 +1242,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 +1291,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 +1304,7 @@ class LLMClient:
                         "content": [{"text": user_message}],
                     }
                 ],
-                inferenceConfig={
-                    "temperature": self.config.temperature,
-                    "maxTokens": self.config.max_tokens,
-                },
+                inferenceConfig=inference_config,
             )
 
             content = (

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
 
 # ---------------------------------------------------------------------------
@@ -91,9 +91,9 @@ review:
   max_diff_lines: 4500
 
   # Max changed logical blocks for Enclosing Scopes strategy (diff_only mode)
-  max_scope_blocks: 10
+  max_scope_blocks: 8
 
-  # Max lines in a single enclosing scope before falling back to file_skeleton
+  # Max lines in a single enclosing scope before falling back to Adaptive Diff
   # (prevents sending entire large classes to the LLM)
   max_scope_lines: 250
 
@@ -138,4 +138,4 @@ output:
 
 debug:
   dump: false
-  dump_file: "logs/debug.log"
+  dump_file: "logs/debug.log"

src/prompts/review_prompt.md.template

@@ -4,82 +4,18 @@
 - Error handling: swallowed exceptions (empty catch), missing logging at critical points, generic error messages to end users.
 - Readability: methods too long or with too many responsibilities (SRP), poor naming, dead/commented-out code.
 - Duplication: repeated logic that should be extracted/reused.
-- Testability: hard-to-mock dependencies, business logic mixed with I/O.
 - Unused code: unused local variables, method parameters, private fields/methods, unreachable code, and unused imports/usings.
-- Unnecessary allocations in hot paths (loops, frequently-called requests).
-
-<!-- lang: cs,ts -->
-## Performance
-- Use of `StringBuilder` vs string concatenation in loops.
-- Blocking synchronous operations where async should be used (I/O, network calls).
-
-<!-- lang: cs,ts,sql -->
-## Concurrency / Thread-safety
-- Race conditions in shared code (static fields, singletons).
-- Correct use of locks/semaphores, avoid deadlocks.
-- Thread-safe collections where needed (`ConcurrentDictionary`, etc).
-
-<!-- lang: all -->
-## Configuration & Secrets
-- Hardcoded values that should be in configuration (connection strings, URLs, timeouts).
-- Secrets/API keys accidentally committed.
-
-<!-- lang: cs,ts -->
-## Dependencies & Compatibility
-- New dependencies added without clear justification - unnecessary or outdated packages.
-- Breaking changes when updating package versions.
+- Mandatory language consistency: Newly added or modified identifiers, developer-facing comments, and documentation must use the same natural language already established by the surrounding code and project. Report mixed-language naming or documentation as a `style` finding on the identifier declaration or comment line. For example, a Portuguese method name in a codebase whose existing identifiers are English is a violation. Do not flag names imposed by external APIs, standard technical terms, or localized user-facing text.
 
 <!-- lang: cs -->
 ## C#
-- Naming Conventions & Casing: follow Microsoft's official C# naming guidelines (https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/coding-style/identifier-names).
-- XML docs: follow Microsoft's official documentation guidance (https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/xmldoc/).
+- Mandatory naming conventions: Every newly added or modified C# identifier must follow Microsoft's official naming guidance. Report each violation as a `style` finding on the    identifier's declaration line. Use PascalCase for types, namespaces, all methods and local functions, public or protected members, and constants; prefix interfaces with `I`; use camelCase for parameters and local variables; use `_camelCase` for private or internal instance fields and `s_camelCase` for private or internal static fields. Names must be meaningful and descriptive, and nonstandard abbreviations must be avoided. Reference: https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/coding-style/identifier-names
+- Mandatory XML documentation: Every newly added or modified public or protected C# type and member must have valid XML documentation comments.
+Report missing documentation as a `style` finding on the declaration line. Require `<summary>` and, when applicable, `<param>`, `<typeparam>` and
+`<returns>` elements. Follow Microsoft's XML documentation guidance: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/xmldoc/
+- Mandatory null safety: Report a `bug` whenever newly added or modified
+code dereferences an externally supplied reference-type parameter without first validating it for null, unless non-nullability is explicitly
+established by preceding code. Recommend `ArgumentNullException.ThrowIfNull(parameter)` and report the finding on the first unsafe dereference.
 - Async: avoid `async void` (except handlers), use `ConfigureAwait(false)` in libraries, don't block with `.Result`/`.Wait()`.
 - Nullable refs: correct `?` usage, avoid unjustified `!`.
-- LINQ: avoid redundant iterations, N+1 queries with EF Core.
-- Disposal: proper use of `IDisposable`/`using` for resources (streams, connections, etc).
 - Immutability: prefer `readonly`, records, immutable types.
-
-<!-- lang: cs,sql -->
-## Logging & Observability
-- Appropriate log levels (Debug vs Info vs Warning vs Error).
-- Don't log sensitive data (PII, passwords, tokens).
-
-<!-- lang: sql -->
-## Migrations / Database (given your SQL/EF stack)
-- Destructive changes to columns/tables with existing data (data loss risk).
-- Migrations that lock large tables in production.
-
-<!-- lang: sql -->
-## SQL
-- Avoid `SELECT *`; specify columns explicitly.
-- Check for parameterized queries (avoid string concatenation → SQL injection).
-- Indexes: flag queries likely to cause table scans on large tables.
-- Transactions: ensure multi-step critical operations are wrapped in a transaction.
-- Naming conventions for tables/columns consistent with the rest of the schema.
-
-<!-- lang: html -->
-## HTML
-- A11y: `alt`, `aria-*`, labels on inputs, semantic tags (`<button>` vs `<div onclick>`).
-- Semantic tags where they apply (`<button>`, `<label>`, `<ul>`/`<li>`) over generic `<div>`/`<span>`. Landmarks (`<header>`/`<nav>`/`<main>`) apply to shell/layout, not feature components.
-- No inline `style=""` for static styling - use the component's `.less` file. `[style.x]`/`[ngStyle]` ok for dynamic values.
-
-<!-- lang: ts,html -->
-## TypeScript / Angular
-- Follow the Angular style guide (https://angular.dev/style-guide).
-- Avoid `any`, prefer explicit types.
-- RxJS: unsubscribe via async pipe, `takeUntil`, or `takeUntilDestroyed`.
-- Use `OnPush` where it makes sense.
-- Separate presentation (component) from business logic (services); avoid heavy template logic.
-- Files: kebab-case + type suffix (`select-maintenance-plan-step.component.ts/.html/.less`).
-- Classes: PascalCase matching file name, no type suffix (`SelectMaintenancePlanStep`, not `...Component`).
-- Selectors: kebab-case with project prefix (`app-select-maintenance-plan-step`).
-- `.less` files named like their component; use `:host`, avoid global style leaks.
-
-<!-- lang: all -->
-## Review Process Notes (meta)
-- Distinguish blocking comments (must-fix) from suggestions (nice-to-have) - this matters a lot for an automated reviewer, so it doesn't hold up merges over trivial issues.
-- If the change is purely formatting/whitespace, do not comment on it.
-- Ignore auto-generated files (generated migrations, `*.designer.cs`, `node_modules`, etc.) unless they contain manually-added code.
-- Flag only issues relevant to the diff/change being reviewed, not the entire file, unless the change requires it.
-- Before flagging something as "missing", verify it isn't present in the surrounding unchanged context (lines without `+`/`-`). Only flag genuinely absent elements, not elements outside the shown diff hunk.
-- Priority order: Security > Functional bugs > Maintainability > Style.

src/tfs_client.py

@@ -324,8 +324,7 @@ class TFSClient:
         For ``diff_only`` scope (default), builds a standard unified diff for
         each changed file and appends an XML context block produced by
         :class:`~src.context_extractor.ContextExtractor` (one of
-        ``<enclosing_scopes>``, ``<file_skeleton>``, ``<sql_statement>``, or
-        ``<adaptive_diff>``).  The block is preserved verbatim by
+        ``<enclosing_scopes>`` or ``<adaptive_diff>``). The block is preserved verbatim by
         :py:meth:`GitUtils.filter_diff_additions_only` so the LLM receives
         structured scope context without consuming the entire file.
 
@@ -500,18 +499,15 @@ class TFSClient:
 
         Fetches the old version from the target branch and the new version
         from the source branch, then generates a standard unified diff with
-        3 lines of context using :py:mod:`difflib`.
+        5 lines of context using :py:mod:`difflib`.
 
         After the diff lines an XML context block is appended, produced by
         :class:`~src.context_extractor.ContextExtractor`:
 
-        * ``<enclosing_scopes>`` — the function(s)/method(s) enclosing
-          the changed lines (Scenario A: ≤ max_scope_blocks distinct blocks)
-        * ``<file_skeleton>`` — structural outline of the whole file
-          (Scenario B: > max_scope_blocks blocks, or scope exceeds max_scope_lines)
-        * ``<sql_statement>`` — the full SQL statement for SQL files
-        * ``<adaptive_diff>`` — surrounding context lines when AST parsing
-          is unavailable or the language is unsupported
+        * ``<enclosing_scopes>`` — the AST scope(s) enclosing the changed
+          lines when they fit the configured block and line limits
+        * ``<adaptive_diff>`` — surrounding context lines when AST extraction
+          is unavailable, unsupported, fails, or exceeds those limits
 
         The XML block is preserved verbatim by
         :py:meth:`GitUtils.filter_diff_additions_only`.
@@ -565,7 +561,7 @@ class TFSClient:
             fromfile=f"a{original_path}",
             tofile=f"b{file_path}",
             lineterm="",
-            n=3,
+            n=5,
         ))
 
         if not diff:
@@ -581,8 +577,8 @@ class TFSClient:
         raw_diff = list(diff)
         result = [f"diff --git a{original_path} b{file_path}"] + raw_diff
 
-        # Build the AST-based context block (Enclosing Scopes / File Skeleton /
-        # Adaptive Diff fallback) and append it after the diff section.
+        # Build the AST-based context block (Enclosing Scopes or Adaptive Diff
+        # fallback) and append it after the diff section.
         if new_lines:
             new_content = "\n".join(new_lines)
             file_diff_text = "\n".join(result)

code_review_ai_cli-2.2.4.dist-info/RECORD

@@ -1,17 +0,0 @@
-src/__init__.py,sha256=BNfzb1HoMlgLc9MNEzc8Ne7USol7NHRUcMn7ISQ41sY,259
-src/ai_review.py,sha256=Wfeo72uTsjuoKMW5ToqFi6edfVIWTMgqPIbv9_W8Z-Y,34482
-src/config.py,sha256=_k0XPY-XVO6xjgwT2zWfox1AQztbk6fkqeqmiSFcGBA,16435
-src/context_extractor.py,sha256=qyiAUjznPfWyZw9VN34nf7OYcZrPUp92pUvR_Y7uSi0,24466
-src/formatter.py,sha256=68kz1U6tMndLcmtJRImN4jAIpxXtog3cKtiJ-zc3S0M,19027
-src/git_utils.py,sha256=yq31qkIXEbuv4zVGNwqW92N-X66SfyldSPCe5i0cX30,9812
-src/llm_client.py,sha256=4WMDs23FxHnrjRDfsbCvedtILYZA00Slss0XrSVvtLE,53672
-src/prompt_utils.py,sha256=FnWgHQ7UW8dEKW-4R7ngpL6DNqbW7xFEKi5JsZ7348E,2045
-src/tfs_client.py,sha256=tZ7-UyNmayPWoptDntefUWDb2By98WkJr4v5MtEM80I,37744
-src/token_estimator.py,sha256=4_4TXhefaNi7KHomwhhWbt7GB6KfubCQVBEbD3YoK5Q,3192
-src/prompts/config.yaml.template,sha256=JlUSywkr0w2K94SzkbHJkkPuxM04gckfjyTJY5yPiHg,4827
-src/prompts/review_prompt.md.template,sha256=hoGP4C6hQQpqDPVzwRTWuS5HCbaUyOgFllciKO8R61I,5019
-code_review_ai_cli-2.2.4.dist-info/METADATA,sha256=3fRvsCtLrA_LsCmxsQEXFcF9Dit6HUW0kk8aRsuke6s,5040
-code_review_ai_cli-2.2.4.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-code_review_ai_cli-2.2.4.dist-info/entry_points.txt,sha256=hzKqoXIQVpiCe4H-XV0DZcKwJY6Uj3M-WvBMEQtwr3o,49
-code_review_ai_cli-2.2.4.dist-info/top_level.txt,sha256=74rtVfumQlgAPzR5_2CgYN24MB0XARCg0t-gzk6gTrM,4
-code_review_ai_cli-2.2.4.dist-info/RECORD,,