open-code-review-toolkit 0.8.2__tar.gz → 0.8.3__tar.gz

{open_code_review_toolkit-0.8.2 → open_code_review_toolkit-0.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: open-code-review-toolkit
-Version: 0.8.2
+Version: 0.8.3
 Summary: Unofficial GitLab CI integration layer for Open Code Review
 Project-URL: Homepage, https://github.com/xeonvs/open-code-review-toolkit
 Project-URL: Repository, https://github.com/xeonvs/open-code-review-toolkit

{open_code_review_toolkit-0.8.2 → open_code_review_toolkit-0.8.3}/src/ocr_toolkit/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.8.2'
-__version_tuple__ = version_tuple = (0, 8, 2)
+__version__ = version = '0.8.3'
+__version_tuple__ = version_tuple = (0, 8, 3)
 
 __commit_id__ = commit_id = None

{open_code_review_toolkit-0.8.2 → open_code_review_toolkit-0.8.3}/src/ocr_toolkit/ocr_result.py

@@ -27,6 +27,23 @@ MAX_TOOLKIT_MCP_TOOL_NAME_CHARS = 4_096
 MAX_TOOLKIT_MCP_USAGE_COUNT = 1_000_000_000
 TOOLKIT_MCP_SERVER_NAME_RE = re.compile(r"^[A-Za-z0-9_-]{1,64}$")
 
+# Closed names whose numeric call counts may appear in the public review summary.
+# Dynamic external MCP tools remain represented by the receipt's verified
+# per-server aggregate so provider-controlled names do not cross into GitLab.
+PUBLIC_REVIEW_TOOL_CALL_NAMES = frozenset(
+    {
+        "code_comment",
+        "code_search",
+        "context_get",
+        "context_list",
+        "file_find",
+        "file_read",
+        "file_read_diff",
+        "ocr_toolkit_evidence",
+        "task_done",
+    }
+)
+
 
 class OcrResultMissing(Exception):
     """The OCR result artifact is missing or unreadable on disk."""

{open_code_review_toolkit-0.8.2 → open_code_review_toolkit-0.8.3}/src/ocr_toolkit/posting/formatting.py

@@ -20,6 +20,7 @@ from ocr_toolkit.common.redaction import redact_sensitive
 from ocr_toolkit.ocr_result import (
     MAX_TOOLKIT_MCP_USAGE_COUNT,
     MAX_TOOLKIT_MCP_USAGE_SERVERS,
+    PUBLIC_REVIEW_TOOL_CALL_NAMES,
     SUPPORTED_TOOLKIT_RESULT_SCHEMA_VERSIONS,
     TOOLKIT_MCP_SERVER_NAME_RE,
 )
@@ -45,8 +46,6 @@ from ocr_toolkit.posting.settings import (
     MAX_REVIEWER_GUIDE_LABEL_CHARS,
     MAX_REVIEWER_GUIDE_LOCATION_CHARS,
     MAX_REVIEWER_GUIDE_TEXT_CHARS,
-    MAX_TOOL_CALL_NAME_CHARS,
-    MAX_TOOL_CALL_SUMMARY_TOOLS,
     SUGGESTION_HEADER,
     post_badges,
     post_emoji,
@@ -374,32 +373,25 @@ def nonnegative_int(value: Any) -> int | None:
     return None
 
 
-def truncate_tool_call_name(name: str) -> str:
-    """Return a compact tool name for one-line MR summaries."""
-
-    if len(name) <= MAX_TOOL_CALL_NAME_CHARS:
-        return name
-
-    return name[: MAX_TOOL_CALL_NAME_CHARS - 3].rstrip() + "..."
-
-
 def tool_call_name(value: Any) -> str:
-    """Extract a displayable tool name from common OCR tool-call shapes."""
+    """Extract one closed public tool name from common OCR call shapes."""
 
     if isinstance(value, str):
-        return clean_text(value)
+        name = clean_text(value)
+        return name if name in PUBLIC_REVIEW_TOOL_CALL_NAMES else ""
 
     if not isinstance(value, dict):
         return ""
 
     for key in ("name", "tool", "tool_name"):
         name = clean_text(value.get(key))
-        if name:
+        if name in PUBLIC_REVIEW_TOOL_CALL_NAMES:
             return name
 
     function_value = value.get("function")
     if isinstance(function_value, dict):
-        return clean_text(function_value.get("name"))
+        name = clean_text(function_value.get("name"))
+        return name if name in PUBLIC_REVIEW_TOOL_CALL_NAMES else ""
 
     return ""
 
@@ -407,14 +399,17 @@ def tool_call_name(value: Any) -> str:
 def tool_call_counts_from_items(
     items: list[Any],
 ) -> tuple[int | None, list[tuple[str, int]]]:
-    """Summarize a list-style OCR tool_calls payload."""
+    """Summarize admitted calls from a legacy list-style OCR payload."""
 
     counts: dict[str, int] = {}
     for item in items:
         name = tool_call_name(item)
         if not name:
             continue
-        counts[name] = counts.get(name, 0) + 1
+        count = counts.get(name, 0) + 1
+        if count > MAX_TOOLKIT_MCP_USAGE_COUNT:
+            return None, []
+        counts[name] = count
 
     total = sum(counts.values())
     if total == 0 and items:
@@ -424,51 +419,52 @@ def tool_call_counts_from_items(
 
 
 def format_tool_calls_summary(tool_calls: Any) -> str:
-    """Return one bounded MR summary line for OCR tool-call statistics."""
+    """Return one bounded MR line for admitted non-zero OCR tool counts."""
 
     entries: list[tuple[str, int]]
     total: int | None
-    scalar_total = nonnegative_int(tool_calls)
-    if scalar_total is not None:
-        total = scalar_total
-        entries = []
-    elif isinstance(tool_calls, list):
+    if isinstance(tool_calls, list):
         total, entries = tool_call_counts_from_items(tool_calls)
     elif isinstance(tool_calls, dict):
         by_tool_value = tool_calls.get("by_tool")
         entries = []
-        by_tool_total = 0
-        valid_by_tool_count = False
+        admitted_total = 0
 
         if isinstance(by_tool_value, dict):
             for raw_name, raw_count in by_tool_value.items():
-                count = nonnegative_int(raw_count)
-                if count is None:
+                if not isinstance(raw_name, str) or raw_name not in PUBLIC_REVIEW_TOOL_CALL_NAMES:
                     continue
-                name = clean_text(raw_name)
-                if not name:
+                if (
+                    not isinstance(raw_count, int)
+                    or isinstance(raw_count, bool)
+                    or not 0 < raw_count <= MAX_TOOLKIT_MCP_USAGE_COUNT
+                ):
                     continue
-                valid_by_tool_count = True
-                by_tool_total += count
-                if count > 0:
-                    entries.append((name, count))
+                admitted_total += raw_count
+                if admitted_total > MAX_TOOLKIT_MCP_USAGE_COUNT:
+                    return ""
+                entries.append((raw_name, raw_count))
 
         calls_value = tool_calls.get("calls")
-        if valid_by_tool_count:
-            list_total = None
-        elif isinstance(calls_value, list):
+        if not by_tool_value and isinstance(calls_value, list):
             list_total, entries = tool_call_counts_from_items(calls_value)
         else:
             list_total = None
 
-        total = nonnegative_int(tool_calls.get("total"))
-        if total is None:
-            if valid_by_tool_count:
-                total = by_tool_total
-            elif list_total is not None:
+        if "total" in tool_calls:
+            raw_total = tool_calls["total"]
+            if (
+                not isinstance(raw_total, int)
+                or isinstance(raw_total, bool)
+                or not 0 < raw_total <= MAX_TOOLKIT_MCP_USAGE_COUNT
+            ):
+                return ""
+            total = raw_total
+        else:
+            if list_total is not None:
                 total = list_total
-            elif by_tool_value == {}:
-                total = 0
+            elif entries:
+                total = admitted_total
             else:
                 return ""
     else:
@@ -476,21 +472,14 @@ def format_tool_calls_summary(tool_calls: Any) -> str:
 
     if total is None:
         return ""
-    if total == 0:
+    if total == 0 or not entries:
+        return ""
+    if sum(count for _name, count in entries) > total:
         return ""
 
     line = f"- all OCR tool calls: {total} total"
-    if not entries:
-        return line
-
     entries.sort(key=lambda item: (-item[1], item[0]))
-    shown_entries = entries[:MAX_TOOL_CALL_SUMMARY_TOOLS]
-    detail_parts = [
-        f"{inline_code(truncate_tool_call_name(name))}: {count}" for name, count in shown_entries
-    ]
-    omitted_entries = len(entries) - len(shown_entries)
-    if omitted_entries > 0:
-        detail_parts.append(f"+{omitted_entries} more")
+    detail_parts = [f"{inline_code(name)}: {count}" for name, count in entries]
 
     return f"{line} ({', '.join(detail_parts)})"
 

{open_code_review_toolkit-0.8.2 → open_code_review_toolkit-0.8.3}/src/ocr_toolkit/posting/settings.py

@@ -53,12 +53,6 @@ DEFAULT_MAX_POST_COMMENTS = 50
 MAX_POST_COMMENTS_HARD_LIMIT = 200
 
 
-MAX_TOOL_CALL_SUMMARY_TOOLS = 6
-
-
-MAX_TOOL_CALL_NAME_CHARS = 48
-
-
 MAX_REVIEWER_GUIDE_COMMENTS = 6
 
 

{open_code_review_toolkit-0.8.2 → open_code_review_toolkit-0.8.3}/src/ocr_toolkit/review_runner.py

@@ -75,6 +75,7 @@ from ocr_toolkit.evidence.review_context import (
 from ocr_toolkit.evidence.store import EvidenceStore, EvidenceStoreError
 from ocr_toolkit.ocr_result import (
     MAX_TOOLKIT_MCP_USAGE_COUNT,
+    PUBLIC_REVIEW_TOOL_CALL_NAMES,
     TOOLKIT_RESULT_KEY,
     TOOLKIT_RESULT_SCHEMA_VERSION,
     OcrResultMalformed,
@@ -117,6 +118,10 @@ BACKGROUND_SOFT_WARNING_RE = re.compile(
     r"\[ocr\] --background-file content is ([0-9]{1,12}) characters, exceeding the "
     r"recommended ([0-9]{1,12}) \(continuing but review quality might be impacted\)\n?\Z"
 )
+MAX_TOOLS_NORMALIZATION_RE = re.compile(
+    r"\[ocr\] --max-tools ([0-9]{1,12}) is below minimum ([0-9]{1,12}), "
+    r"using ([0-9]{1,12})\n?\Z"
+)
 BACKGROUND_HARD_CHARACTER_RE = re.compile(
     r"Error: background content is ([0-9]{1,12}) characters, exceeding the hard limit of "
     r"([0-9]{1,12}) \(aborting\)\n?\Z"
@@ -149,9 +154,10 @@ class ReviewRunnerError(Exception):
 
 @dataclass(frozen=True, slots=True)
 class BackgroundQualification:
-    """Carry one toolkit-authored warning derived from installed OCR output."""
+    """Carry closed toolkit-authored projections of installed OCR diagnostics."""
 
     warning: str | None = None
+    operator_notices: tuple[str, ...] = ()
 
 
 class BackgroundQualificationRejected(ReviewRunnerError):
@@ -593,22 +599,6 @@ def _publication_sinks(payload: dict[str, object]) -> list[object]:
     warnings = payload.get("warnings")
     if warnings is not None:
         sinks.append(warnings)
-    tool_calls = payload.get("tool_calls")
-    if isinstance(tool_calls, list):
-        for item in tool_calls:
-            if not isinstance(item, dict):
-                continue
-            sinks.extend(item.get(key) for key in ("name", "tool", "tool_name") if key in item)
-            function = item.get("function")
-            if isinstance(function, dict) and "name" in function:
-                sinks.append(function.get("name"))
-    elif isinstance(tool_calls, dict):
-        by_tool = tool_calls.get("by_tool")
-        if isinstance(by_tool, dict):
-            sinks.extend(by_tool)
-        calls = tool_calls.get("calls")
-        if isinstance(calls, list):
-            sinks.extend(_publication_sinks({"tool_calls": calls}))
     manifest = payload.get("manifest")
     coverage = manifest.get("coverage") if isinstance(manifest, dict) else None
     failed = coverage.get("failed") if isinstance(coverage, dict) else None
@@ -633,23 +623,6 @@ def _is_publication_sink_path(path: tuple[object, ...]) -> bool:
         and path[2] in QUARANTINE_COMMENT_FIELDS
     ):
         return True
-    if len(path) == 3 and path[:2] == ("tool_calls", "by_tool"):
-        return True
-    if (
-        len(path) == 4
-        and path[0] == "tool_calls"
-        and isinstance(path[1], int)
-        and path[2] == "function"
-        and path[3] == "name"
-    ):
-        return True
-    if (
-        len(path) == 3
-        and path[0] == "tool_calls"
-        and isinstance(path[1], int)
-        and path[2] in {"name", "tool", "tool_name"}
-    ):
-        return True
     return bool(
         len(path) >= 5
         and path[:3] == ("manifest", "coverage", "failed")
@@ -658,6 +631,16 @@ def _is_publication_sink_path(path: tuple[object, ...]) -> bool:
     )
 
 
+def _is_static_public_tool_key_path(path: tuple[object, ...]) -> bool:
+    """Return whether a map key is one compile-time public tool label."""
+
+    return bool(
+        len(path) == 3
+        and path[:2] == ("tool_calls", "by_tool")
+        and path[2] in PUBLIC_REVIEW_TOOL_CALL_NAMES
+    )
+
+
 def _sanitize_nonpublication_fields(
     payload: dict[str, object], *, budgets: TextBudgets, matcher: ForbiddenMatcher
 ) -> tuple[dict[str, object], Counter[str], int]:
@@ -679,7 +662,9 @@ def _sanitize_nonpublication_fields(
             child_path = (*path, key)
             if isinstance(source, dict):
                 assert isinstance(key, str)
-                if not _is_publication_sink_path(child_path):
+                if not _is_publication_sink_path(
+                    child_path
+                ) and not _is_static_public_tool_key_path(child_path):
                     checked_key = check_text(
                         key,
                         budgets=budgets,
@@ -783,6 +768,7 @@ def _closed_tool_calls(value: object, *, allowed_tools: frozenset[str]) -> dict[
         tool: count
         for tool, count in by_tool.items()
         if tool in allowed_tools
+        and tool in PUBLIC_REVIEW_TOOL_CALL_NAMES
         and isinstance(count, int)
         and not isinstance(count, bool)
         and 0 < count <= MAX_TOOLKIT_MCP_USAGE_COUNT
@@ -809,17 +795,9 @@ def _canonical_result_projection(payload: dict[str, object]) -> bytes:
         else comment
         for comment in comments
     ]
-    tool_calls = payload.get("tool_calls")
-    projected_tool_calls: object
-    if isinstance(tool_calls, dict):
-        total = tool_calls.get("total")
-        by_tool = tool_calls.get("by_tool")
-        projected_tool_calls = {
-            "total": total,
-            "by_tool": (dict(sorted(by_tool.items())) if isinstance(by_tool, dict) else by_tool),
-        }
-    else:
-        projected_tool_calls = tool_calls
+    projected_tool_calls = _closed_tool_calls(
+        payload.get("tool_calls"), allowed_tools=PUBLIC_REVIEW_TOOL_CALL_NAMES
+    )
     projection = {
         "outcome": {
             "status": outcome.status,
@@ -953,9 +931,7 @@ def _finalize_ocr_result(
     filtered = False
     publication: dict[str, object] = {"state": "passed"}
     usage: dict[str, int] = {}
-    allowed_tools = frozenset(
-        tool for capability in composition.capabilities for tool in capability.tools
-    )
+    allowed_tools = PUBLIC_REVIEW_TOOL_CALL_NAMES
 
     def finalize(payload: dict[str, object]) -> dict[str, object]:
         nonlocal filtered, publication, usage
@@ -1160,7 +1136,7 @@ def _read_bounded_artifact(path: Path, *, limit: int, label: str) -> bytes:
 
 
 def _parse_background_preview(*, returncode: int, stderr: bytes) -> BackgroundQualification:
-    """Classify only exact installed-OCR background warning and rejection forms."""
+    """Classify only exact installed-OCR preview diagnostics consumed by the toolkit."""
 
     try:
         text = stderr.decode("utf-8", errors="strict")
@@ -1170,21 +1146,41 @@ def _parse_background_preview(*, returncode: int, stderr: bytes) -> BackgroundQu
     soft_matches = [
         match for line in lines if (match := BACKGROUND_SOFT_WARNING_RE.fullmatch(line)) is not None
     ]
+    max_tools_matches = [
+        match for line in lines if (match := MAX_TOOLS_NORMALIZATION_RE.fullmatch(line)) is not None
+    ]
     hard_character = BACKGROUND_HARD_CHARACTER_RE.fullmatch(text)
     hard_file = BACKGROUND_HARD_FILE_RE.fullmatch(text)
     if returncode == 0:
-        if len(soft_matches) != len(lines) or len(soft_matches) > 1:
+        if (
+            len(soft_matches) + len(max_tools_matches) != len(lines)
+            or len(soft_matches) > 1
+            or len(max_tools_matches) > 1
+        ):
             raise ReviewRunnerError("OCR background preview returned ambiguous diagnostics")
-        if not soft_matches:
-            return BackgroundQualification()
-        actual, limit = (int(value) for value in soft_matches[0].groups())
-        if not 0 < limit < actual:
-            raise ReviewRunnerError("OCR background preview returned invalid thresholds")
-        return BackgroundQualification(
-            warning=(
+        warning: str | None = None
+        if soft_matches:
+            actual, limit = (int(value) for value in soft_matches[0].groups())
+            if not 0 < limit < actual:
+                raise ReviewRunnerError("OCR background preview returned invalid thresholds")
+            warning = (
                 f"Installed OCR reported a {actual}-character review background above its "
                 f"recommended {limit}-character threshold; review continued."
             )
+        operator_notices: tuple[str, ...] = ()
+        if max_tools_matches:
+            requested, minimum, normalized = (int(value) for value in max_tools_matches[0].groups())
+            if not 0 < requested < minimum or normalized != minimum:
+                raise ReviewRunnerError("OCR background preview returned invalid tool limits")
+            operator_notices = (
+                "Installed OCR reported "
+                f"--max-tools {requested} below its CLI minimum and a normalization target "
+                f"of {normalized}; the installed OCR template remains authoritative for the "
+                "effective tool-call limit.",
+            )
+        return BackgroundQualification(
+            warning=warning,
+            operator_notices=operator_notices,
         )
     if hard_character is not None:
         actual, limit = (int(value) for value in hard_character.groups())
@@ -1304,6 +1300,8 @@ def _run_background_qualified_review(
             f"OCR background qualification warning: {qualification.warning}",
             file=sys.stderr,
         )
+    for notice in qualification.operator_notices:
+        print(f"OCR argument qualification notice: {notice}", file=sys.stderr)
     return (
         run_review(
             result_path,