git-commit-message 0.5.1__tar.gz → 0.6.0__tar.gz

{git_commit_message-0.5.1 → git_commit_message-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-commit-message
-Version: 0.5.1
+Version: 0.6.0
 Summary: Generate Git commit messages from staged changes using OpenAI GPT
 Maintainer-email: Mina Her <minacle@live.com>
 License: This is free and unencumbered software released into the public domain.
@@ -45,6 +45,7 @@ Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 Requires-Dist: babel>=2.17.0
 Requires-Dist: openai>=2.6.1
+Requires-Dist: tiktoken>=0.12.0
 
 # git-commit-message
 
@@ -115,6 +116,19 @@ git-commit-message --one-line "optional context"
 git-commit-message --one-line --max-length 50 "optional context"
 ```
 
+- Chunk long diffs by token budget (0 = single chunk + summary, -1 = disable chunking):
+
+```sh
+# force a single summary pass over the whole diff (default)
+git-commit-message --chunk-tokens 0 "optional context"
+
+# chunk the diff into ~4000-token pieces before summarising
+git-commit-message --chunk-tokens 4000 "optional context"
+
+# disable summarisation and use the legacy one-shot prompt
+git-commit-message --chunk-tokens -1 "optional context"
+```
+
 - Commit immediately with editor:
 
 ```sh
@@ -144,6 +158,7 @@ Environment:
 - `OPENAI_API_KEY`: required
 - `GIT_COMMIT_MESSAGE_MODEL` or `OPENAI_MODEL`: optional (default: `gpt-5-mini`)
 - `GIT_COMMIT_MESSAGE_LANGUAGE`: optional (default: `en-GB`)
+- `GIT_COMMIT_MESSAGE_CHUNK_TOKENS`: optional token budget per diff chunk (default: 0 = single chunk + summary; -1 disables summarisation)
 
 ## AI‑generated code notice
 

{git_commit_message-0.5.1 → git_commit_message-0.6.0}/README.md

@@ -67,6 +67,19 @@ git-commit-message --one-line "optional context"
 git-commit-message --one-line --max-length 50 "optional context"
 ```
 
+- Chunk long diffs by token budget (0 = single chunk + summary, -1 = disable chunking):
+
+```sh
+# force a single summary pass over the whole diff (default)
+git-commit-message --chunk-tokens 0 "optional context"
+
+# chunk the diff into ~4000-token pieces before summarising
+git-commit-message --chunk-tokens 4000 "optional context"
+
+# disable summarisation and use the legacy one-shot prompt
+git-commit-message --chunk-tokens -1 "optional context"
+```
+
 - Commit immediately with editor:
 
 ```sh
@@ -96,6 +109,7 @@ Environment:
 - `OPENAI_API_KEY`: required
 - `GIT_COMMIT_MESSAGE_MODEL` or `OPENAI_MODEL`: optional (default: `gpt-5-mini`)
 - `GIT_COMMIT_MESSAGE_LANGUAGE`: optional (default: `en-GB`)
+- `GIT_COMMIT_MESSAGE_CHUNK_TOKENS`: optional token budget per diff chunk (default: 0 = single chunk + summary; -1 disables summarisation)
 
 ## AI‑generated code notice
 

{git_commit_message-0.5.1 → git_commit_message-0.6.0}/pyproject.toml

@@ -1,12 +1,13 @@
 [project]
 name = "git-commit-message"
-version = "0.5.1"
+version = "0.6.0"
 description = "Generate Git commit messages from staged changes using OpenAI GPT"
 readme = "README.md"
 requires-python = ">=3.13"
 dependencies = [
 	"babel>=2.17.0",
 	"openai>=2.6.1",
+	"tiktoken>=0.12.0",
 ]
 maintainers = [{ name = "Mina Her", email = "minacle@live.com" }]
 license = { file = "UNLICENSE" }

{git_commit_message-0.5.1 → git_commit_message-0.6.0}/src/git_commit_message/__init__.py

@@ -5,6 +5,4 @@ This module exposes only public symbols in accordance with the codestyle guide.
 
 from ._cli import main
 
-__all__ = (
-    "main",
-)
+__all__ = ("main",)

{git_commit_message-0.5.1 → git_commit_message-0.6.0}/src/git_commit_message/_cli.py

@@ -1,17 +1,24 @@
-from __future__ import annotations
-
 """Command-line interface entry point.
 
 Collect staged changes from the repository and call an OpenAI GPT model
 to generate a commit message, or create a commit straight away.
 """
 
+from __future__ import annotations
+
 from argparse import ArgumentParser, Namespace
+from os import environ
 from pathlib import Path
-import sys
+from sys import exit as sys_exit
+from sys import stderr
 from typing import Final
 
-from ._git import commit_with_message, get_repo_root, get_staged_diff, has_staged_changes
+from ._git import (
+    commit_with_message,
+    get_repo_root,
+    get_staged_diff,
+    has_staged_changes,
+)
 from ._gpt import (
     generate_commit_message,
     generate_commit_message_with_info,
@@ -19,6 +26,18 @@ from ._gpt import (
 )
 
 
+def _env_chunk_tokens_default() -> int | None:
+    """Return chunk token default from env if valid, else None."""
+
+    raw: str | None = environ.get("GIT_COMMIT_MESSAGE_CHUNK_TOKENS")
+    if raw is None:
+        return None
+    try:
+        return int(raw)
+    except ValueError:
+        return None
+
+
 def _build_parser() -> ArgumentParser:
     """Create the CLI argument parser.
 
@@ -92,12 +111,24 @@ def _build_parser() -> ArgumentParser:
         help="Maximum subject (first line) length (default: 72).",
     )
 
+    parser.add_argument(
+        "--chunk-tokens",
+        dest="chunk_tokens",
+        type=int,
+        default=None,
+        help=(
+            "Target token budget per diff chunk. "
+            "0 forces a single chunk with summarisation; -1 disables summarisation (legacy one-shot). "
+            "If omitted, uses GIT_COMMIT_MESSAGE_CHUNK_TOKENS when set (default: 0)."
+        ),
+    )
+
     return parser
 
 
 def _run(
-    *,
     args: Namespace,
+    /,
 ) -> int:
     """Main execution logic.
 
@@ -114,37 +145,45 @@ def _run(
 
     repo_root: Path = get_repo_root()
 
-    if not has_staged_changes(cwd=repo_root):
-        print("No staged changes. Run 'git add' and try again.", file=sys.stderr)
+    if not has_staged_changes(repo_root):
+        print("No staged changes. Run 'git add' and try again.", file=stderr)
         return 2
 
-    diff_text: str = get_staged_diff(cwd=repo_root)
+    diff_text: str = get_staged_diff(repo_root)
 
     hint: str | None = args.description if isinstance(args.description, str) else None
 
+    chunk_tokens: int | None = args.chunk_tokens
+    if chunk_tokens is None:
+        chunk_tokens = _env_chunk_tokens_default()
+    if chunk_tokens is None:
+        chunk_tokens = 0
+
     result: CommitMessageResult | None = None
     try:
         if args.debug:
             result = generate_commit_message_with_info(
-                diff=diff_text,
-                hint=hint,
-                model=args.model,
-                single_line=getattr(args, "one_line", False),
-                subject_max=getattr(args, "max_length", None),
-                language=getattr(args, "language", None),
+                diff_text,
+                hint,
+                args.model,
+                getattr(args, "one_line", False),
+                getattr(args, "max_length", None),
+                getattr(args, "language", None),
+                chunk_tokens,
             )
             message = result.message
         else:
             message = generate_commit_message(
-                diff=diff_text,
-                hint=hint,
-                model=args.model,
-                single_line=getattr(args, "one_line", False),
-                subject_max=getattr(args, "max_length", None),
-                language=getattr(args, "language", None),
+                diff_text,
+                hint,
+                args.model,
+                getattr(args, "one_line", False),
+                getattr(args, "max_length", None),
+                getattr(args, "language", None),
+                chunk_tokens,
             )
     except Exception as exc:  # noqa: BLE001 - to preserve standard output messaging
-        print(f"Failed to generate commit message: {exc}", file=sys.stderr)
+        print(f"Failed to generate commit message: {exc}", file=stderr)
         return 3
 
     # Option: force single-line message
@@ -198,9 +237,9 @@ def _run(
         print(message)
 
     if args.edit:
-        rc: int = commit_with_message(message=message, edit=True, cwd=repo_root)
+        rc: int = commit_with_message(message, True, repo_root)
     else:
-        rc = commit_with_message(message=message, edit=False, cwd=repo_root)
+        rc = commit_with_message(message, False, repo_root)
 
     return rc
 
@@ -215,8 +254,8 @@ def main() -> None:
     args: Namespace = parser.parse_args()
 
     if args.edit and not args.commit:
-        print("'--edit' must be used together with '--commit'.", file=sys.stderr)
-        sys.exit(2)
+        print("'--edit' must be used together with '--commit'.", file=stderr)
+        sys_exit(2)
 
-    code: int = _run(args=args)
-    sys.exit(code)
+    code: int = _run(args)
+    sys_exit(code)

{git_commit_message-0.5.1 → git_commit_message-0.6.0}/src/git_commit_message/_git.py

@@ -1,18 +1,18 @@
-from __future__ import annotations
-
 """Git-related helper functions.
 
 Provides repository root discovery, extraction of staged changes, and
 creating commits from a message.
 """
 
+from __future__ import annotations
+
 from pathlib import Path
-import subprocess
+from subprocess import CalledProcessError, check_call, check_output, run
 
 
 def get_repo_root(
-    *,
     cwd: Path | None = None,
+    /,
 ) -> Path:
     """Find the repository root from the current working directory.
 
@@ -29,7 +29,7 @@ def get_repo_root(
 
     start: Path = cwd or Path.cwd()
     try:
-        out: bytes = subprocess.check_output(
+        out: bytes = check_output(
             [
                 "git",
                 "rev-parse",
@@ -37,7 +37,7 @@ def get_repo_root(
             ],
             cwd=str(start),
         )
-    except subprocess.CalledProcessError as exc:  # noqa: TRY003
+    except CalledProcessError as exc:  # noqa: TRY003
         raise RuntimeError("Not a Git repository.") from exc
 
     root = Path(out.decode().strip())
@@ -45,28 +45,28 @@ def get_repo_root(
 
 
 def has_staged_changes(
-    *,
     cwd: Path,
+    /,
 ) -> bool:
     """Check whether there are staged changes."""
 
     try:
-        subprocess.check_call(
+        check_call(
             ["git", "diff", "--cached", "--quiet", "--exit-code"],
             cwd=str(cwd),
         )
         return False
-    except subprocess.CalledProcessError:
+    except CalledProcessError:
         return True
 
 
 def get_staged_diff(
-    *,
     cwd: Path,
+    /,
 ) -> str:
     """Return the staged changes as diff text."""
 
-    out: bytes = subprocess.check_output(
+    out: bytes = check_output(
         [
             "git",
             "diff",
@@ -81,10 +81,10 @@ def get_staged_diff(
 
 
 def commit_with_message(
-    *,
     message: str,
     edit: bool,
     cwd: Path,
+    /,
 ) -> int:
     """Create a commit with the given message.
 
@@ -108,7 +108,7 @@ def commit_with_message(
         cmd.append("--edit")
 
     try:
-        completed = subprocess.run(cmd, cwd=str(cwd), check=False)
+        completed = run(cmd, cwd=str(cwd), check=False)
         return int(completed.returncode)
     except OSError as exc:  # e.g., editor launch failure, etc.
         raise RuntimeError(f"Failed to run 'git commit': {exc}") from exc

git_commit_message-0.6.0/src/git_commit_message/_gpt.py

@@ -0,0 +1,604 @@
+"""Generate Git commit messages by calling an OpenAI GPT model.
+
+Migrated to use OpenAI Responses API (client.responses.create).
+"""
+
+from __future__ import annotations
+
+from babel import Locale
+from openai import OpenAI
+from openai.types.responses import Response, ResponseInputParam
+from os import environ
+from tiktoken import Encoding, encoding_for_model, get_encoding
+from typing import Final
+
+
+_DEFAULT_MODEL: Final[str] = "gpt-5-mini"
+_DEFAULT_LANGUAGE: Final[str] = "en-GB"
+
+
+def _encoding_for_model(
+    model: str,
+    /,
+) -> Encoding:
+    try:
+        return encoding_for_model(model)
+    except Exception:
+        return get_encoding("cl100k_base")
+
+
+def _count_tokens(
+    text: str,
+    *,
+    model: str,
+) -> int:
+    encoding = _encoding_for_model(model)
+    return len(encoding.encode(text))
+
+
+def _build_system_prompt(
+    single_line: bool,
+    subject_max: int | None,
+    language: str,
+    /,
+) -> str:
+    display_language: str = _language_display(language)
+    max_len = subject_max or 72
+    if single_line:
+        return (
+            f"You are an expert Git commit message generator. "
+            f"Always use '{display_language}' spelling and style. "
+            f"Return a single-line imperative subject only (<= {max_len} chars). "
+            f"Do not include a body, bullet points, or any rationale. Do not include any line breaks. "
+            f"Consider the user-provided auxiliary context if present. "
+            f"Return only the commit message text (no code fences or prefixes like 'Commit message:')."
+        )
+    return (
+        f"You are an expert Git commit message generator. "
+        f"Always use '{display_language}' spelling and style. "
+        f"The subject line is mandatory: you MUST start the output with the subject as the very first non-empty line, "
+        f"in imperative mood, and keep it <= {max_len} chars. Insert exactly one blank line after the subject. "
+        f"Never start with bullets, headings, labels, or any other text. Then include a body in this format.\n\n"
+        f"Example format (do not include the --- lines in the output):\n\n"
+        f"---\n\n"
+        f"<Subject line>\n\n"
+        f"- <detail 1>\n"
+        f"- <detail 2>\n"
+        f"- <detail N>\n\n"
+        f"<Rationale label translated into the target language>: <1-2 concise sentences explaining the intent and why>\n\n"
+        f"---\n\n"
+        f"Guidelines:\n"
+        f"- The first non-empty line MUST be the subject line; include exactly one blank line after it.\n"
+        f"- Never place bullets, headings, or labels before the subject line.\n"
+        f"- Use '-' bullets; keep each bullet short (<= 1 line).\n"
+        f"- Prefer imperative mood verbs (Add, Fix, Update, Remove, Refactor, Document, etc.).\n"
+        f"- Focus on what changed and why; avoid copying diff hunks verbatim.\n"
+        f"- The only allowed label is the equivalent of 'Rationale:' translated into the target language; do not add other headings or prefaces.\n"
+        f"- All text (subject, bullets, rationale label, rationale content) MUST be in the target language: '{display_language}'. Do not mix other languages.\n"
+        f"- Do not include the '---' delimiter lines, code fences, or any surrounding labels like 'Commit message:'.\n"
+        f"- Do not copy or reuse any example text verbatim; produce original content based on the provided diff and context.\n"
+        f"- If few details are necessary, include at least one bullet summarising the key change.\n"
+        f"- If you cannot provide any body content, still output the subject line; the subject line must never be omitted.\n"
+        f"- Consider the user-provided auxiliary context if present.\n"
+        f"Return only the commit message text in the above format (no code fences or extra labels)."
+    )
+
+
+def _language_display(
+    language: str,
+    /,
+) -> str:
+    """Return a human-friendly language display like 'ko-KR, Korean (South Korea)'."""
+
+    try:
+        locale = Locale.parse(language, sep="-")
+    except Exception:
+        return language
+
+    tag_parts = [
+        locale.language,
+        locale.script,
+        locale.territory,
+        locale.variant,
+    ]
+    tag = "-".join(part for part in tag_parts if part)
+    if not tag:
+        return language
+
+    english_name = locale.get_display_name("en") or ""
+    if not english_name:
+        return f"[{tag}]"
+
+    return f"{english_name.capitalize()} [{tag}]"
+
+
+def _instructions(
+    single_line: bool,
+    subject_max: int | None,
+    language: str,
+    /,
+) -> str:
+    """Create the system/developer instructions string for the Responses API."""
+    return _build_system_prompt(single_line, subject_max, language)
+
+
+class CommitMessageResult:
+    """Hold the generated commit message and debugging information.
+
+    Notes
+    -----
+    Treat all fields as read-only by convention.
+    """
+
+    __slots__ = (
+        "message",
+        "model",
+        "prompt",
+        "response_text",
+        "response_id",
+        "prompt_tokens",
+        "completion_tokens",
+        "total_tokens",
+    )
+
+    def __init__(
+        self,
+        /,
+        *,
+        message: str,
+        model: str,
+        prompt: str,
+        response_text: str,
+        response_id: str | None,
+        prompt_tokens: int | None,
+        completion_tokens: int | None,
+        total_tokens: int | None,
+    ) -> None:
+        self.message = message
+        self.model = model
+        self.prompt = prompt
+        self.response_text = response_text
+        self.response_id = response_id
+        self.prompt_tokens = prompt_tokens
+        self.completion_tokens = completion_tokens
+        self.total_tokens = total_tokens
+
+
+def _resolve_model(
+    model: str | None,
+    /,
+) -> str:
+    """Resolve the model name."""
+
+    return (
+        model
+        or environ.get("GIT_COMMIT_MESSAGE_MODEL")
+        or environ.get("OPENAI_MODEL")
+        or _DEFAULT_MODEL
+    )
+
+
+def _resolve_language(
+    language: str | None,
+    /,
+) -> str:
+    """Resolve the target language/locale tag used for output style."""
+
+    return language or environ.get("GIT_COMMIT_MESSAGE_LANGUAGE") or _DEFAULT_LANGUAGE
+
+
+def _build_responses_input(
+    diff: str,
+    hint: str | None,
+    /,
+) -> ResponseInputParam:
+    """Compose Responses API input items, separating auxiliary context and diff.
+
+    Returns
+    -------
+    ResponseInputParam
+        The list of input items to send to the Responses API.
+    """
+
+    hint_content: str | None = (
+        f"# Auxiliary context (user-provided)\n{hint}" if hint else None
+    )
+    diff_content: str = f"# Changes (diff)\n{diff}"
+
+    input_items: ResponseInputParam = []
+    if hint_content:
+        input_items.append(
+            {
+                "role": "user",
+                "content": [
+                    {"type": "input_text", "text": hint_content},
+                ],
+            }
+        )
+    input_items.append(
+        {
+            "role": "user",
+            "content": [
+                {"type": "input_text", "text": diff_content},
+            ],
+        }
+    )
+
+    return input_items
+
+
+def _split_diff_into_hunks(
+    diff: str,
+    /,
+) -> list[str]:
+    lines = diff.splitlines(keepends=True)
+    hunks: list[str] = []
+    file_header: list[str] = []
+    current_hunk: list[str] | None = None
+
+    for line in lines:
+        if line.startswith("diff --git "):
+            if current_hunk:
+                hunks.append("".join(current_hunk))
+                current_hunk = None
+            file_header = [line]
+            continue
+
+        if line.startswith("@@"):
+            if current_hunk:
+                hunks.append("".join(current_hunk))
+            base_header = file_header[:] if file_header else []
+            current_hunk = base_header + [line]
+            continue
+
+        if current_hunk is not None:
+            current_hunk.append(line)
+            continue
+
+        if file_header:
+            file_header.append(line)
+            continue
+
+        # Lines outside a diff header/hunk; keep as standalone hunk
+        current_hunk = [line]
+
+    if current_hunk:
+        hunks.append("".join(current_hunk))
+
+    return hunks
+
+
+def _build_diff_chunks(
+    hunks: list[str],
+    chunk_tokens: int,
+    model: str,
+    /,
+) -> list[str]:
+    if chunk_tokens <= 0:
+        raise ValueError("chunk_tokens must be positive when chunking is enabled")
+
+    chunks: list[str] = []
+    current: list[str] = []
+
+    for hunk in hunks:
+        candidate = "".join(current + [hunk])
+        token_count = _count_tokens(candidate, model=model)
+
+        if token_count <= chunk_tokens:
+            current.append(hunk)
+            continue
+
+        if current:
+            chunks.append("".join(current))
+            current = [hunk]
+        else:
+            single_tokens = _count_tokens(hunk, model=model)
+            if single_tokens > chunk_tokens:
+                raise ValueError(
+                    "chunk_tokens is too small to fit a single diff hunk; increase the value or disable chunking"
+                )
+            current = [hunk]
+
+    if current:
+        chunks.append("".join(current))
+
+    return chunks
+
+
+def _build_chunk_summary_prompt() -> str:
+    return (
+        "You are an expert developer summarising Git diffs. "
+        "Write detailed English bullet points describing what changed and why. "
+        "Do not copy large code blocks verbatim; focus on behavior and intent. "
+        "Be verbose when useful; this summary will later be used to craft a commit message."
+    )
+
+
+def _summarise_diff_chunks(
+    chunks: list[str],
+    model: str,
+    client: OpenAI,
+    /,
+) -> list[tuple[str, Response]]:
+    if not chunks:
+        return []
+
+    instructions = _build_chunk_summary_prompt()
+    summaries: list[tuple[str, Response]] = []
+
+    for chunk in chunks:
+        resp = client.responses.create(
+            model=model,
+            instructions=instructions,
+            input=[
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "input_text",
+                            "text": f"# Diff chunk\n{chunk}",
+                        }
+                    ],
+                }
+            ],
+        )
+
+        text: str = (resp.output_text or "").strip()
+        if not text:
+            raise RuntimeError("An empty chunk summary was generated.")
+
+        summaries.append((text, resp))
+
+    return summaries
+
+
+def _generate_commit_from_summaries(
+    summaries: list[str],
+    hint: str | None,
+    model: str,
+    single_line: bool,
+    subject_max: int | None,
+    language: str,
+    client: OpenAI,
+    /,
+) -> tuple[str, Response]:
+    instructions = _instructions(single_line, subject_max, language)
+    sections: list[str] = []
+
+    if hint:
+        sections.append(f"# Auxiliary context (user-provided)\n{hint}")
+
+    if summaries:
+        numbered = [
+            f"Summary {idx + 1}:\n{summary}" for idx, summary in enumerate(summaries)
+        ]
+        sections.append(
+            "# Combined summaries of the commit (in English)\n" + "\n\n".join(numbered)
+        )
+    else:
+        sections.append("# No summaries available")
+
+    user_content = "\n\n".join(sections)
+
+    resp = client.responses.create(
+        model=model,
+        instructions=instructions,
+        input=[
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "input_text",
+                        "text": user_content,
+                    }
+                ],
+            }
+        ],
+    )
+
+    text: str = (resp.output_text or "").strip()
+    if not text:
+        raise RuntimeError("An empty commit message was generated from summaries.")
+
+    return text, resp
+
+
+def _build_combined_prompt(
+    diff: str,
+    hint: str | None,
+    content_label: str = "Changes (diff)",
+    /,
+) -> str:
+    """Compose a combined string of hint and content for debug/info output."""
+
+    hint_content: str | None = (
+        f"# Auxiliary context (user-provided)\n{hint}" if hint else None
+    )
+    content: str = f"# {content_label}\n{diff}"
+    return "\n\n".join([part for part in (hint_content, content) if part is not None])
+
+
+def generate_commit_message(
+    diff: str,
+    hint: str | None,
+    model: str | None,
+    single_line: bool = False,
+    subject_max: int | None = None,
+    language: str | None = None,
+    chunk_tokens: int | None = 0,
+    /,
+) -> str:
+    """Generate a commit message using an OpenAI GPT model."""
+
+    chosen_model: str = _resolve_model(model)
+    chosen_language: str = _resolve_language(language)
+    api_key = environ.get("OPENAI_API_KEY")
+    if not api_key:
+        raise RuntimeError("The OPENAI_API_KEY environment variable is required.")
+
+    client = OpenAI(api_key=api_key)
+
+    normalized_chunk_tokens = 0 if chunk_tokens is None else chunk_tokens
+
+    if normalized_chunk_tokens != -1:
+        hunks = _split_diff_into_hunks(diff)
+        if normalized_chunk_tokens == 0:
+            chunks = ["".join(hunks) if hunks else diff]
+        elif normalized_chunk_tokens > 0:
+            chunks = _build_diff_chunks(
+                hunks,
+                normalized_chunk_tokens,
+                chosen_model,
+            )
+        else:
+            chunks = ["".join(hunks) if hunks else diff]
+
+        summary_pairs = _summarise_diff_chunks(
+            chunks,
+            chosen_model,
+            client,
+        )
+        summary_texts = [text for text, _ in summary_pairs]
+        text, _ = _generate_commit_from_summaries(
+            summary_texts,
+            hint,
+            chosen_model,
+            single_line,
+            subject_max,
+            chosen_language,
+            client,
+        )
+    else:
+        input_items = _build_responses_input(diff, hint)
+
+        resp = client.responses.create(
+            model=chosen_model,
+            instructions=_instructions(single_line, subject_max, chosen_language),
+            input=input_items,
+        )
+
+        text = (resp.output_text or "").strip()
+
+    if not text:
+        raise RuntimeError("An empty commit message was generated.")
+    return text
+
+
+def generate_commit_message_with_info(
+    diff: str,
+    hint: str | None,
+    model: str | None,
+    single_line: bool = False,
+    subject_max: int | None = None,
+    language: str | None = None,
+    chunk_tokens: int | None = 0,
+    /,
+) -> CommitMessageResult:
+    """Return the OpenAI GPT call result together with debugging information.
+
+    Returns
+    -------
+    CommitMessageResult
+        The generated message, token usage, and prompt/response text.
+    """
+
+    chosen_model: str = _resolve_model(model)
+    chosen_language: str = _resolve_language(language)
+    api_key = environ.get("OPENAI_API_KEY")
+    if not api_key:
+        raise RuntimeError("The OPENAI_API_KEY environment variable is required.")
+
+    client = OpenAI(api_key=api_key)
+
+    normalized_chunk_tokens = 0 if chunk_tokens is None else chunk_tokens
+
+    if normalized_chunk_tokens != -1:
+        hunks = _split_diff_into_hunks(diff)
+        if normalized_chunk_tokens == 0:
+            chunks = ["".join(hunks) if hunks else diff]
+        elif normalized_chunk_tokens > 0:
+            chunks = _build_diff_chunks(
+                hunks,
+                normalized_chunk_tokens,
+                chosen_model,
+            )
+        else:
+            chunks = ["".join(hunks) if hunks else diff]
+
+        summary_pairs = _summarise_diff_chunks(
+            chunks,
+            chosen_model,
+            client,
+        )
+        summary_texts = [text for text, _ in summary_pairs]
+        response_text, final_resp = _generate_commit_from_summaries(
+            summary_texts,
+            hint,
+            chosen_model,
+            single_line,
+            subject_max,
+            chosen_language,
+            client,
+        )
+
+        total_tokens: int | None = None
+        prompt_tokens: int | None = None
+        completion_tokens: int | None = None
+
+        if final_resp.usage:
+            total_tokens = (total_tokens or 0) + (final_resp.usage.total_tokens or 0)
+            prompt_tokens = (prompt_tokens or 0) + (final_resp.usage.input_tokens or 0)
+            completion_tokens = (completion_tokens or 0) + (
+                final_resp.usage.output_tokens or 0
+            )
+
+        for _, resp in summary_pairs:
+            usage = resp.usage
+            if usage is None:
+                continue
+            total_tokens = (total_tokens or 0) + (usage.total_tokens or 0)
+            prompt_tokens = (prompt_tokens or 0) + (usage.input_tokens or 0)
+            completion_tokens = (completion_tokens or 0) + (usage.output_tokens or 0)
+
+        combined_prompt = _build_combined_prompt(
+            "\n".join(summary_texts),
+            hint,
+            "Combined summaries (English)",
+        )
+
+        response_id: str | None = final_resp.id
+
+    else:
+        combined_prompt = _build_combined_prompt(diff, hint)
+        input_items = _build_responses_input(diff, hint)
+
+        resp = client.responses.create(
+            model=chosen_model,
+            instructions=_instructions(single_line, subject_max, chosen_language),
+            input=input_items,
+        )
+
+        response_text = (resp.output_text or "").strip()
+        response_id = resp.id
+        usage = resp.usage
+        prompt_tokens: int | None = None
+        completion_tokens: int | None = None
+        total_tokens: int | None = None
+        if usage is not None:
+            total_tokens = usage.total_tokens
+            prompt_tokens = usage.input_tokens
+            completion_tokens = usage.output_tokens
+
+    if not response_text:
+        raise RuntimeError("An empty commit message was generated.")
+
+    return CommitMessageResult(
+        message=response_text,
+        model=chosen_model,
+        prompt=combined_prompt,
+        response_text=response_text,
+        response_id=response_id,
+        prompt_tokens=prompt_tokens,
+        completion_tokens=completion_tokens,
+        total_tokens=total_tokens,
+    )

{git_commit_message-0.5.1 → git_commit_message-0.6.0}/src/git_commit_message.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-commit-message
-Version: 0.5.1
+Version: 0.6.0
 Summary: Generate Git commit messages from staged changes using OpenAI GPT
 Maintainer-email: Mina Her <minacle@live.com>
 License: This is free and unencumbered software released into the public domain.
@@ -45,6 +45,7 @@ Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 Requires-Dist: babel>=2.17.0
 Requires-Dist: openai>=2.6.1
+Requires-Dist: tiktoken>=0.12.0
 
 # git-commit-message
 
@@ -115,6 +116,19 @@ git-commit-message --one-line "optional context"
 git-commit-message --one-line --max-length 50 "optional context"
 ```
 
+- Chunk long diffs by token budget (0 = single chunk + summary, -1 = disable chunking):
+
+```sh
+# force a single summary pass over the whole diff (default)
+git-commit-message --chunk-tokens 0 "optional context"
+
+# chunk the diff into ~4000-token pieces before summarising
+git-commit-message --chunk-tokens 4000 "optional context"
+
+# disable summarisation and use the legacy one-shot prompt
+git-commit-message --chunk-tokens -1 "optional context"
+```
+
 - Commit immediately with editor:
 
 ```sh
@@ -144,6 +158,7 @@ Environment:
 - `OPENAI_API_KEY`: required
 - `GIT_COMMIT_MESSAGE_MODEL` or `OPENAI_MODEL`: optional (default: `gpt-5-mini`)
 - `GIT_COMMIT_MESSAGE_LANGUAGE`: optional (default: `en-GB`)
+- `GIT_COMMIT_MESSAGE_CHUNK_TOKENS`: optional token budget per diff chunk (default: 0 = single chunk + summary; -1 disables summarisation)
 
 ## AI‑generated code notice
 

{git_commit_message-0.5.1 → git_commit_message-0.6.0}/src/git_commit_message.egg-info/requires.txt

@@ -1,2 +1,3 @@
 babel>=2.17.0
 openai>=2.6.1
+tiktoken>=0.12.0

git_commit_message-0.5.1/src/git_commit_message/_gpt.py

@@ -1,312 +0,0 @@
-from __future__ import annotations
-
-from openai.types.responses import ResponseInputParam
-
-"""Generate Git commit messages by calling an OpenAI GPT model.
-
-Migrated to use OpenAI Responses API (client.responses.create).
-"""
-
-import os
-from typing import Final
-from babel import Locale
-from openai import OpenAI
-
-
-_DEFAULT_MODEL: Final[str] = "gpt-5-mini"
-_DEFAULT_LANGUAGE: Final[str] = "en-GB"
-
-def _build_system_prompt(
-    *,
-    single_line: bool,
-    subject_max: int | None,
-    language: str,
-) -> str:
-    display_language: str = _language_display(language)
-    max_len = subject_max or 72
-    if single_line:
-        return (
-            f"You are an expert Git commit message generator. "
-            f"Always use '{display_language}' spelling and style. "
-            f"Return a single-line imperative subject only (<= {max_len} chars). "
-            f"Do not include a body, bullet points, or any rationale. Do not include any line breaks. "
-            f"Consider the user-provided auxiliary context if present. "
-            f"Return only the commit message text (no code fences or prefixes like 'Commit message:')."
-        )
-    return (
-        f"You are an expert Git commit message generator. "
-        f"Always use '{display_language}' spelling and style. "
-        f"The subject line is mandatory: you MUST start the output with the subject as the very first non-empty line, "
-        f"in imperative mood, and keep it <= {max_len} chars. Insert exactly one blank line after the subject. "
-        f"Never start with bullets, headings, labels, or any other text. Then include a body in this format.\n\n"
-        f"Example format (do not include the --- lines in the output):\n\n"
-        f"---\n\n"
-        f"<Subject line>\n\n"
-        f"- <detail 1>\n"
-        f"- <detail 2>\n"
-        f"- <detail N>\n\n"
-        f"<Rationale label translated into the target language>: <1-2 concise sentences explaining the intent and why>\n\n"
-        f"---\n\n"
-        f"Guidelines:\n"
-        f"- The first non-empty line MUST be the subject line; include exactly one blank line after it.\n"
-        f"- Never place bullets, headings, or labels before the subject line.\n"
-        f"- Use '-' bullets; keep each bullet short (<= 1 line).\n"
-        f"- Prefer imperative mood verbs (Add, Fix, Update, Remove, Refactor, Document, etc.).\n"
-        f"- Focus on what changed and why; avoid copying diff hunks verbatim.\n"
-        f"- The only allowed label is the equivalent of 'Rationale:' translated into the target language; do not add other headings or prefaces.\n"
-        f"- All text (subject, bullets, rationale label, rationale content) MUST be in the target language: '{display_language}'. Do not mix other languages.\n"
-        f"- Do not include the '---' delimiter lines, code fences, or any surrounding labels like 'Commit message:'.\n"
-        f"- Do not copy or reuse any example text verbatim; produce original content based on the provided diff and context.\n"
-        f"- If few details are necessary, include at least one bullet summarising the key change.\n"
-        f"- If you cannot provide any body content, still output the subject line; the subject line must never be omitted.\n"
-        f"- Consider the user-provided auxiliary context if present.\n"
-        f"Return only the commit message text in the above format (no code fences or extra labels)."
-    )
-
-
-def _language_display(language: str) -> str:
-    """Return a human-friendly language display like 'ko-KR, Korean (South Korea)'."""
-
-    try:
-        locale = Locale.parse(language, sep="-")
-    except Exception:
-        return language
-
-    tag_parts = [
-        locale.language,
-        locale.script,
-        locale.territory,
-        locale.variant,
-    ]
-    tag = "-".join(part for part in tag_parts if part)
-    if not tag:
-        return language
-
-    english_name = locale.get_display_name("en") or ""
-    if not english_name:
-        return f"[{tag}]"
-
-    return f"{english_name.capitalize()} [{tag}]"
-
-
-def _instructions(
-    *,
-    single_line: bool,
-    subject_max: int | None,
-    language: str,
-) -> str:
-    """Create the system/developer instructions string for the Responses API."""
-    return _build_system_prompt(single_line=single_line, subject_max=subject_max, language=language)
-
-
-class CommitMessageResult:
-    """Hold the generated commit message and debugging information.
-
-    Notes
-    -----
-    Treat all fields as read-only by convention.
-    """
-
-    __slots__ = (
-        "message",
-        "model",
-        "prompt",
-        "response_text",
-        "response_id",
-        "prompt_tokens",
-        "completion_tokens",
-        "total_tokens",
-    )
-
-    def __init__(
-        self,
-        /,
-        *,
-        message: str,
-        model: str,
-        prompt: str,
-        response_text: str,
-        response_id: str | None,
-        prompt_tokens: int | None,
-        completion_tokens: int | None,
-        total_tokens: int | None,
-    ) -> None:
-        self.message = message
-        self.model = model
-        self.prompt = prompt
-        self.response_text = response_text
-        self.response_id = response_id
-        self.prompt_tokens = prompt_tokens
-        self.completion_tokens = completion_tokens
-        self.total_tokens = total_tokens
-
-
-def _resolve_model(
-    *,
-    model: str | None,
-) -> str:
-    """Resolve the model name."""
-
-    return (
-        model
-        or os.environ.get("GIT_COMMIT_MESSAGE_MODEL")
-        or os.environ.get("OPENAI_MODEL")
-        or _DEFAULT_MODEL
-    )
-
-
-def _resolve_language(
-    *,
-    language: str | None,
-) -> str:
-    """Resolve the target language/locale tag used for output style."""
-
-    return (
-        language
-        or os.environ.get("GIT_COMMIT_MESSAGE_LANGUAGE")
-        or _DEFAULT_LANGUAGE
-    )
-
-
-def _build_responses_input(
-    *,
-    diff: str,
-    hint: str | None,
-) -> ResponseInputParam:
-    """Compose Responses API input items, separating auxiliary context and diff.
-
-    Returns
-    -------
-    ResponseInputParam
-        The list of input items to send to the Responses API.
-    """
-
-    hint_content: str | None = (
-        f"# Auxiliary context (user-provided)\n{hint}" if hint else None
-    )
-    diff_content: str = f"# Changes (diff)\n{diff}"
-
-    input_items: ResponseInputParam = []
-    if hint_content:
-        input_items.append(
-            {
-                "role": "user",
-                "content": [
-                    {"type": "input_text", "text": hint_content},
-                ],
-            }
-        )
-    input_items.append(
-        {
-            "role": "user",
-            "content": [
-                {"type": "input_text", "text": diff_content},
-            ],
-        }
-    )
-
-    return input_items
-
-
-def _build_combined_prompt(*, diff: str, hint: str | None) -> str:
-    """Compose a combined string of hint and diff for debug/info output."""
-    hint_content: str | None = (
-        f"# Auxiliary context (user-provided)\n{hint}" if hint else None
-    )
-    diff_content: str = f"# Changes (diff)\n{diff}"
-    return "\n\n".join([part for part in (hint_content, diff_content) if part is not None])
-
-
-def generate_commit_message(
-    *,
-    diff: str,
-    hint: str | None,
-    model: str | None,
-    single_line: bool = False,
-    subject_max: int | None = None,
-    language: str | None = None,
-) -> str:
-    """Generate a commit message using an OpenAI GPT model."""
-
-    chosen_model: str = _resolve_model(model=model)
-    chosen_language: str = _resolve_language(language=language)
-    api_key = os.environ.get("OPENAI_API_KEY")
-    if not api_key:
-        raise RuntimeError("The OPENAI_API_KEY environment variable is required.")
-
-    client = OpenAI(api_key=api_key)
-
-    input_items = _build_responses_input(diff=diff, hint=hint)
-
-    # Use Responses API to generate a single response (send hint and diff as separate user inputs)
-    resp = client.responses.create(
-        model=chosen_model,
-        instructions=_instructions(single_line=single_line, subject_max=subject_max, language=chosen_language),
-        input=input_items,
-    )
-
-    # Prefer SDK convenience aggregate text if available
-    text: str = (resp.output_text or "").strip()
-    if not text:
-        raise RuntimeError("An empty commit message was generated.")
-    return text
-
-
-def generate_commit_message_with_info(
-    *,
-    diff: str,
-    hint: str | None,
-    model: str | None,
-    single_line: bool = False,
-    subject_max: int | None = None,
-    language: str | None = None,
-) -> CommitMessageResult:
-    """Return the OpenAI GPT call result together with debugging information.
-
-    Returns
-    -------
-    CommitMessageResult
-        The generated message, token usage, and prompt/response text.
-    """
-
-    chosen_model: str = _resolve_model(model=model)
-    chosen_language: str = _resolve_language(language=language)
-    api_key = os.environ.get("OPENAI_API_KEY")
-    if not api_key:
-        raise RuntimeError("The OPENAI_API_KEY environment variable is required.")
-
-    client = OpenAI(api_key=api_key)
-    combined_prompt = _build_combined_prompt(diff=diff, hint=hint)
-    input_items = _build_responses_input(diff=diff, hint=hint)
-
-    resp = client.responses.create(
-        model=chosen_model,
-        instructions=_instructions(single_line=single_line, subject_max=subject_max, language=chosen_language),
-        input=input_items,
-    )
-
-    response_text: str = (resp.output_text or "").strip()
-    if not response_text:
-        raise RuntimeError("An empty commit message was generated.")
-
-    response_id: str | None = resp.id
-    usage = resp.usage
-    prompt_tokens: int | None = None
-    completion_tokens: int | None = None
-    total_tokens: int | None = None
-    if usage is not None:
-        # Responses API exposes input/output/total token fields.
-        total_tokens = usage.total_tokens
-        prompt_tokens = usage.input_tokens
-        completion_tokens = usage.output_tokens
-
-    return CommitMessageResult(
-        message=response_text,
-        model=chosen_model,
-        prompt=combined_prompt,
-        response_text=response_text,
-        response_id=response_id,
-        prompt_tokens=prompt_tokens,
-        completion_tokens=completion_tokens,
-        total_tokens=total_tokens,
-    )