git-cai-cli 0.17.3__tar.gz → 0.17.4__tar.gz

{git_cai_cli-0.17.3 → git_cai_cli-0.17.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-cai-cli
-Version: 0.17.3
+Version: 0.17.4
 Summary: Use LLM to create git commit messages
 Author-email: Thorsten Foltz <thorsten.foltz@live.com>
 License-Expression: MIT

{git_cai_cli-0.17.3 → git_cai_cli-0.17.4}/docs/git-cai.txt

@@ -1099,9 +1099,11 @@ Available configuration keys:
 - `full_files` -- send full working-tree contents of staged files alongside
   the diff (`true`/`false`, default `false`)
 - `max_diff_bytes` -- maximum size (in UTF-8 bytes) of the diff/commit-log
-  sent to the LLM. When the input exceeds this, it is truncated and a marker
-  line is appended so the model knows it was cut. `0` (the default) means no
-  limit. Useful to avoid context-window errors on very large staged changes.
+  sent to the LLM. When the input exceeds this, the largest files are shortened
+  first so every file stays represented, and marker lines tell the model what
+  was cut. `0` (the default) means no limit. You rarely need this for very
+  large staged changes: when a provider rejects the input as too large, git-cai
+  shortens it the same way, warns, and retries up to two times.
 - `pr_to_file` -- when running `--PR`, write the generated PR description
   to a Markdown file in the repository root instead of printing it to
   stdout (`true`/`false`, default `false`)

{git_cai_cli-0.17.3 → git_cai_cli-0.17.4}/docs/man/git-cai.1

@@ -2,12 +2,12 @@
 .\"     Title: git-cai
 .\"    Author: Thorsten Foltz
 .\" Generator: Asciidoctor 2.0.26
-.\"      Date: 2026-11-04
+.\"      Date: 2026-11-06
 .\"    Manual: \ \&
 .\"    Source: \ \&
 .\"  Language: English
 .\"
-.TH "GIT\-CAI" "1" "2026-11-04" "\ \&" "\ \&"
+.TH "GIT\-CAI" "1" "2026-11-06" "\ \&" "\ \&"
 .ie \n(.g .ds Aq \(aq
 .el       .ds Aq '
 .ss \n[.ss] 0
@@ -1829,9 +1829,11 @@ the diff (\f(CRtrue\fP/\f(CRfalse\fP, default \f(CRfalse\fP)
 .  IP \(bu 2.3
 .\}
 \f(CRmax_diff_bytes\fP \(em maximum size (in UTF\-8 bytes) of the diff/commit\-log
-sent to the LLM. When the input exceeds this, it is truncated and a marker
-line is appended so the model knows it was cut. \f(CR0\fP (the default) means no
-limit. Useful to avoid context\-window errors on very large staged changes.
+sent to the LLM. When the input exceeds this, the largest files are shortened
+first so every file stays represented, and marker lines tell the model what
+was cut. \f(CR0\fP (the default) means no limit. You rarely need this for very
+large staged changes: when a provider rejects the input as too large, git\-cai
+shortens it the same way, warns, and retries up to two times.
 .RE
 .sp
 .RS 4

{git_cai_cli-0.17.3 → git_cai_cli-0.17.4}/src/git_cai_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.17.3'
-__version_tuple__ = version_tuple = (0, 17, 3)
+__version__ = version = '0.17.4'
+__version_tuple__ = version_tuple = (0, 17, 4)
 
-__commit_id__ = commit_id = 'g4c48b7f68'
+__commit_id__ = commit_id = 'gf30a44c67'

{git_cai_cli-0.17.3 → git_cai_cli-0.17.4}/src/git_cai_cli/core/gitutils.py

@@ -349,26 +349,55 @@ def git_diff_excluding(
     return result.stdout
 
 
+# Where an independently trimmable part of an LLM payload starts: one file's
+# diff, or a block appended after the diff. A stray match inside file content
+# only creates one more part, which is harmless.
+_PAYLOAD_PART_RE = re.compile(
+    r"^(?=diff --git "
+    r"|--- (?:Full file contents|Additional context from the author) ---)",
+    re.MULTILINE,
+)
+
+
+def shorten_diff(diff: str, max_bytes: int) -> str:
+    """Cut ``diff`` to about ``max_bytes`` UTF-8 bytes, largest parts first.
+
+    Parts below their fair share stay whole and the others split what is left,
+    so every file keeps its header and the start of its changes. Text without
+    file headers (a commit log) is one part, which makes this a plain tail cut.
+    Each cut adds a short marker, so the result can slightly exceed the limit.
+    """
+    parts = [part.encode("utf-8") for part in _PAYLOAD_PART_RE.split(diff) if part]
+    remaining = max_bytes
+    shares = [0] * len(parts)
+    by_size = sorted(range(len(parts)), key=lambda i: len(parts[i]))
+    for position, index in enumerate(by_size):
+        shares[index] = min(len(parts[index]), remaining // (len(parts) - position))
+        remaining -= shares[index]
+
+    shortened = []
+    for part, share in zip(parts, shares):
+        # errors="ignore" drops a multibyte character split by the byte slice.
+        text = part[:share].decode("utf-8", errors="ignore")
+        if share < len(part):
+            text += f"\n[... {len(part) - share} bytes omitted ...]\n"
+        shortened.append(text)
+    return "".join(shortened)
+
+
 def truncate_diff(diff: str, max_bytes: int) -> tuple[str, bool]:
-    """Truncate ``diff`` to at most ``max_bytes`` UTF-8 bytes.
+    """Truncate ``diff`` to about ``max_bytes`` UTF-8 bytes.
 
     A ``max_bytes`` of 0 (or negative) means "no limit" and the diff is
     returned unchanged — preserving the default behavior. When truncation
     occurs, a marker line is appended so both the LLM and the user know the
     input was cut. Returns ``(possibly_truncated_diff, was_truncated)``.
     """
-    if max_bytes <= 0:
-        return diff, False
-
-    encoded = diff.encode("utf-8")
-    if len(encoded) <= max_bytes:
+    if max_bytes <= 0 or len(diff.encode("utf-8")) <= max_bytes:
         return diff, False
 
-    # Cut on a UTF-8 safe boundary: decoding with errors="ignore" drops any
-    # partial trailing multibyte sequence left by the byte-level slice.
-    truncated = encoded[:max_bytes].decode("utf-8", errors="ignore")
     marker = f"\n\n[... diff truncated: exceeded max_diff_bytes={max_bytes} ...]"
-    return truncated + marker, True
+    return shorten_diff(diff, max_bytes) + marker, True
 
 
 def apply_diff_limit(text: str, config: dict, *, label: str = "Input") -> str:

{git_cai_cli-0.17.3 → git_cai_cli-0.17.4}/src/git_cai_cli/core/llm.py

@@ -18,7 +18,11 @@ from urllib.parse import urlparse
 
 import requests
 from git_cai_cli.core.config import CONFIG_DIR, is_custom_provider
-from git_cai_cli.core.gitutils import classify_changed_paths, paths_from_diff
+from git_cai_cli.core.gitutils import (
+    classify_changed_paths,
+    paths_from_diff,
+    shorten_diff,
+)
 from git_cai_cli.core.languages import LANGUAGE_MAP
 from git_cai_cli.core.prompts_fallback import (
     HARDCODED_CHANGELOG_PROMPT,
@@ -30,6 +34,7 @@ from git_cai_cli.core.prompts_fallback import (
     HARDCODED_SPLIT_PROMPT,
     HARDCODED_SQUASH_PROMPT,
 )
+from git_cai_cli.core.validate import _extract_api_error_message
 from requests.adapters import HTTPAdapter
 from urllib3.util.retry import Retry
 
@@ -179,6 +184,37 @@ def _http_post(*args, **kwargs):
     return response
 
 
+# Model limits change too often for a table, and the provider's rejection
+# names them, so an oversized request is shortened and retried instead.
+_OVERFLOW_STATUS_CODES = (400, 413, 422)
+_OVERFLOW_RE = re.compile(
+    r"too (?:long|large)|exceed|maximum (?:context|prompt)|reduce the length",
+    re.IGNORECASE,
+)
+# Skips numbers glued to a name or version, like a date in a model name.
+_OVERFLOW_SIZE_RE = re.compile(r"(?<![\w.-])\d[\d,]{2,}\b")
+_OVERFLOW_RETRIES = 2
+
+
+def _overflow_shrink_factor(exc: requests.HTTPError) -> float | None:
+    """Return how much to shrink the input after a "too many tokens" rejection.
+
+    ``None`` means ``exc`` is some other error. Providers word the rejection
+    differently, but the first two numbers are the limit and the actual size,
+    and the smaller one is the limit. Without them, halve the input.
+    """
+    response = exc.response
+    if response is None or response.status_code not in _OVERFLOW_STATUS_CODES:
+        return None
+    message = _extract_api_error_message(response)
+    if not _OVERFLOW_RE.search(message):
+        return None
+    sizes = [int(n.replace(",", "")) for n in _OVERFLOW_SIZE_RE.findall(message)[:2]]
+    if len(sizes) < 2 or sizes[0] == sizes[1]:
+        return 0.5
+    return 0.9 * min(sizes) / max(sizes)
+
+
 def load_prompt_file(
     config_key: str,
     config: Dict[str, Any],
@@ -968,7 +1004,8 @@ class CommitMessageGenerator:
     def _dispatch_generate(self, content: str, system_prompt: str) -> str:
         """
         Route to the right provider. ``system_prompt`` comes from the
-        matching ``_build_*_prompt``; ``content`` is the git output.
+        matching ``_build_*_prompt``; ``content`` is the git output. Input the
+        provider rejects as too large is shortened and retried.
         """
         self._scan_for_secrets(content)
 
@@ -987,12 +1024,30 @@ class CommitMessageGenerator:
 
         log.debug("Using provider '%s' for generation.", provider)
 
-        if openai_compatible:
-            return self.generate_openai_compatible(
-                content, provider, system_prompt_override=system_prompt
-            )
+        def call_provider(text: str) -> str:
+            if openai_compatible:
+                return self.generate_openai_compatible(
+                    text, provider, system_prompt_override=system_prompt
+                )
+            return model_dispatch[provider](text, system_prompt_override=system_prompt)
 
-        return model_dispatch[provider](content, system_prompt_override=system_prompt)
+        sent = content
+        for _ in range(_OVERFLOW_RETRIES):
+            try:
+                return call_provider(sent)
+            except requests.HTTPError as exc:
+                factor = _overflow_shrink_factor(exc)
+                if factor is None:
+                    raise
+            target = int(len(sent.encode("utf-8")) * factor)
+            log.warning(
+                "The input is too large for this model. Retrying with the largest "
+                "files shortened to about %d bytes in total, so the result may "
+                "miss details from the cut parts.",
+                target,
+            )
+            sent = shorten_diff(content, target)
+        return call_provider(sent)
 
     # ---------------------------
     # MODEL CALLS

{git_cai_cli-0.17.3 → git_cai_cli-0.17.4}/src/git_cai_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-cai-cli
-Version: 0.17.3
+Version: 0.17.4
 Summary: Use LLM to create git commit messages
 Author-email: Thorsten Foltz <thorsten.foltz@live.com>
 License-Expression: MIT

git_cai_cli-0.17.4/src/git_cai_cli.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.17.4",
+  "distance": 0,
+  "node": "gf30a44c6710bb1a22b8c320490b0812500e30f72",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-11-06"
+}

{git_cai_cli-0.17.3 → git_cai_cli-0.17.4}/tests/unit/test_gitutils.py

@@ -17,6 +17,7 @@ import subprocess
 from pathlib import Path
 from unittest.mock import MagicMock, patch
 
+import pytest
 from git_cai_cli.core.gitutils import (
     append_to_caiignore,
     changed_files_range,
@@ -108,6 +109,55 @@ def test_truncate_diff_handles_multibyte_boundary():
     assert "diff truncated" in out
 
 
+def _file_diff(name: str, body: str) -> str:
+    return f"diff --git a/{name} b/{name}\n--- a/{name}\n+++ b/{name}\n{body}\n"
+
+
+def test_truncate_diff_keeps_files_after_a_huge_one():
+    """A plain tail cut would lose every file sorted after the huge one."""
+    first = _file_diff("a.py", "+first change")
+    huge = _file_diff("docs.md", "+" + "x" * 100_000)
+    last = _file_diff("src/z.py", "+last change")
+
+    out, truncated = truncate_diff(first + huge + last, 10_000)
+
+    assert truncated is True
+    assert first in out
+    assert last in out
+    assert "diff --git a/docs.md b/docs.md" in out
+    assert len(out.encode("utf-8")) < 10_200
+
+
+def test_truncate_diff_splits_budget_evenly_between_big_files():
+    diff = _file_diff("a.py", "+" + "x" * 100_000)
+    diff += _file_diff("b.py", "+" + "y" * 100_000)
+
+    out, _ = truncate_diff(diff, 10_000)
+
+    assert out.count("x") == pytest.approx(out.count("y"), abs=20)
+    assert 4_500 < out.count("x") < 5_000
+
+
+def test_truncate_diff_keeps_author_context():
+    diff = _file_diff("big.py", "+" + "x" * 100_000)
+    context = "--- Additional context from the author ---\nwhy this changed"
+
+    out, _ = truncate_diff(f"{diff}\n\n{context}", 1_000)
+
+    assert context in out
+
+
+def test_truncate_diff_cuts_full_file_dump_before_the_diff():
+    diff = _file_diff("a.py", "+change")
+    dump = "\n\n--- Full file contents ---\n" + "x" * 100_000
+
+    out, _ = truncate_diff(diff + dump, 1_000)
+
+    assert diff in out
+    assert "--- Full file contents ---" in out
+    assert "x" * 1_000 not in out
+
+
 # ------------------------------------------------------------------------------
 # find_git_root
 # ------------------------------------------------------------------------------

{git_cai_cli-0.17.3 → git_cai_cli-0.17.4}/tests/unit/test_llm.py

@@ -2,10 +2,13 @@
 Unit tests for git_cai_cli.core.llm module.
 """
 
+import json
 import logging
+import re
 from unittest.mock import MagicMock, patch
 
 import pytest
+import requests
 from git_cai_cli.core.llm import (
     CommitMessageGenerator,
     _http_post,
@@ -136,6 +139,195 @@ def test_dispatch_invalid_model(generator):
         generator._dispatch_generate("diff", "prompt")
 
 
+# oversized input: shorten and retry
+OPENAI_OVERFLOW = (
+    "Input tokens exceed the configured limit of 922000 tokens. "
+    "Your messages resulted in 1346101 tokens. "
+    "Please reduce the length of the messages."
+)
+
+
+def _api_response(status, body):
+    response = requests.Response()
+    response.status_code = status
+    response._content = json.dumps(body).encode()
+    return response
+
+
+def _rejected(message=OPENAI_OVERFLOW, status=400):
+    return _api_response(status, {"error": {"message": message}})
+
+
+def _accepted():
+    return _api_response(200, {"choices": [{"message": {"content": "short message"}}]})
+
+
+def _two_file_diff():
+    return "".join(
+        f"diff --git a/{name} b/{name}\n+{'x' * 50_000}\n"
+        for name in ("docs.md", "src/main.py")
+    )
+
+
+def _dispatch(generator, responses, diff):
+    """Dispatch against canned responses; return the result and each sent input."""
+    mock_post = MagicMock(side_effect=responses)
+    with patch(f"{CommitMessageGenerator.__module__}._http_post", mock_post):
+        result = generator._dispatch_generate(diff, "sys")
+    return result, [
+        call.kwargs["json"]["messages"][-1]["content"]
+        for call in mock_post.call_args_list
+    ]
+
+
+def test_overflow_retries_with_every_file_still_present(generator):
+    diff = _two_file_diff()
+
+    result, sent = _dispatch(generator, [_rejected(), _accepted()], diff)
+
+    assert result == "short message"
+    assert sent[0] == diff
+    assert len(sent) == 2
+    assert "diff --git a/docs.md b/docs.md" in sent[1]
+    assert "diff --git a/src/main.py b/src/main.py" in sent[1]
+
+
+@pytest.mark.parametrize(
+    ("message", "status", "limit", "actual"),
+    [
+        (OPENAI_OVERFLOW, 400, 922_000, 1_346_101),
+        (
+            (
+                "Input tokens exceed the configured limit of 922,000 tokens. "
+                "Your messages resulted in 1,346,101 tokens."
+            ),
+            400,
+            922_000,
+            1_346_101,
+        ),
+        (
+            "prompt is too long: 1346101 tokens > 1000000 maximum",
+            400,
+            1_000_000,
+            1_346_101,
+        ),
+        (
+            (
+                "Request too large for model `grok-20250514` on tokens: "
+                "Limit 6000, Requested 12000"
+            ),
+            413,
+            6_000,
+            12_000,
+        ),
+        (
+            (
+                "The input token count (1346101) exceeds the maximum number of "
+                "tokens allowed (1048576)."
+            ),
+            400,
+            1_048_576,
+            1_346_101,
+        ),
+        (
+            (
+                "This model's maximum context length is 65536 tokens. However, you "
+                "requested 100000 tokens (99000 in the messages, 1000 in the "
+                "completion). Please reduce the length of the messages or completion."
+            ),
+            400,
+            65_536,
+            100_000,
+        ),
+        (
+            (
+                "This model's maximum prompt length is 131072 but the request "
+                "contains 200000 tokens."
+            ),
+            400,
+            131_072,
+            200_000,
+        ),
+        (
+            (
+                "Prompt contains 200000 tokens, too large for model with 131072 "
+                "maximum context length"
+            ),
+            400,
+            131_072,
+            200_000,
+        ),
+        (
+            (
+                "Request too large for model `llama-3.3-70b` on tokens per minute "
+                "(TPM): Limit 6000, Requested 12000"
+            ),
+            413,
+            6_000,
+            12_000,
+        ),
+    ],
+)
+def test_overflow_shrinks_by_what_the_provider_reports(
+    generator, message, status, limit, actual
+):
+    diff = _two_file_diff()
+
+    _, sent = _dispatch(generator, [_rejected(message, status), _accepted()], diff)
+
+    assert len(sent[1]) == pytest.approx(len(diff) * limit / actual * 0.9, abs=200)
+
+
+def test_overflow_without_numbers_halves_the_input(generator):
+    diff = _two_file_diff()
+    rejected = _rejected("Request payload is too large", 413)
+
+    _, sent = _dispatch(generator, [rejected, _accepted()], diff)
+
+    assert len(sent[1]) == pytest.approx(len(diff) * 0.5, abs=200)
+
+
+def test_overflow_second_retry_cuts_from_the_original_diff(generator):
+    """Cutting the first retry's text again would misreport what is omitted."""
+    second = "Limit of 900000 tokens exceeded. You sent 1000000 tokens."
+    diff = _two_file_diff()
+
+    _, sent = _dispatch(generator, [_rejected(), _rejected(second), _accepted()], diff)
+
+    assert len(sent) == 3
+    assert len(sent[2]) < len(sent[1])
+    omitted = sum(map(int, re.findall(r"(\d+) bytes omitted", sent[2])))
+    assert omitted == pytest.approx(len(diff) - len(sent[2]), abs=200)
+
+
+def test_overflow_gives_up_after_two_retries(generator):
+    mock_post = MagicMock(side_effect=[_rejected() for _ in range(5)])
+
+    with (
+        patch(f"{CommitMessageGenerator.__module__}._http_post", mock_post),
+        pytest.raises(requests.HTTPError),
+    ):
+        generator._dispatch_generate(_two_file_diff(), "sys")
+
+    assert mock_post.call_count == 3
+
+
+@pytest.mark.parametrize(
+    ("message", "status"),
+    [("Invalid model", 400), (OPENAI_OVERFLOW, 429), ("Bad gateway", 502)],
+)
+def test_other_errors_are_not_retried(generator, message, status):
+    mock_post = MagicMock(side_effect=[_rejected(message, status), _accepted()])
+
+    with (
+        patch(f"{CommitMessageGenerator.__module__}._http_post", mock_post),
+        pytest.raises(requests.HTTPError),
+    ):
+        generator._dispatch_generate(_two_file_diff(), "sys")
+
+    assert mock_post.call_count == 1
+
+
 # test openai
 def test_generate_openai(generator):
     """

git_cai_cli-0.17.3/src/git_cai_cli.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.17.3",
-  "distance": 0,
-  "node": "g4c48b7f689e10205b1178c36224eeef398baccfe",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-11-04"
-}