git-copilot-commit 0.5.3__tar.gz → 0.5.5__tar.gz

{git_copilot_commit-0.5.3 → git_copilot_commit-0.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-copilot-commit
-Version: 0.5.3
+Version: 0.5.5
 Summary: Automatically generate and commit changes using GitHub Copilot
 Author-email: Dheepak Krishnamurthy <1813121+kdheepak@users.noreply.github.com>
 License-File: LICENSE

{git_copilot_commit-0.5.3 → git_copilot_commit-0.5.5}/src/git_copilot_commit/cli.py

@@ -5,6 +5,7 @@ git-copilot-commit - AI-powered Git commit assistant
 from dataclasses import dataclass
 from pathlib import Path
 import os
+import re
 import sys
 from typing import Annotated, Sequence
 
@@ -94,6 +95,19 @@ class PreparedSplitCommit:
     patch_units: tuple[PatchUnit, ...]
 
 
+CORE_CHANGE_COMMIT_TYPES = frozenset({"feat", "fix", "perf", "refactor", "revert"})
+FOLLOW_UP_COMMIT_TYPE_PRIORITY = {
+    "test": 2,
+    "docs": 3,
+    "style": 4,
+    "chore": 4,
+}
+CONVENTIONAL_COMMIT_TYPE_PATTERN = re.compile(
+    r"^\s*([a-z]+)(?:\([^)\r\n]*\))?(?:!)?:",
+    re.IGNORECASE,
+)
+
+
 def preprocess_cli_args(args: Sequence[str]) -> list[str]:
     """Normalize CLI arguments before Click parses them."""
     processed_args: list[str] = []
@@ -142,6 +156,37 @@ def preprocess_cli_args(args: Sequence[str]) -> list[str]:
     return processed_args
 
 
+def extract_conventional_commit_type(message: str) -> str | None:
+    """Extract the Conventional Commit type from a generated title line."""
+    match = CONVENTIONAL_COMMIT_TYPE_PATTERN.match(message.strip())
+    if match is None:
+        return None
+
+    return match.group(1).lower()
+
+
+def order_prepared_split_commits(
+    prepared_commits: Sequence[PreparedSplitCommit],
+) -> list[PreparedSplitCommit]:
+    """Order planned commits in a developer-friendly execution sequence."""
+
+    def sort_key(item: tuple[int, PreparedSplitCommit]) -> tuple[int, int]:
+        index, prepared_commit = item
+        commit_type = extract_conventional_commit_type(prepared_commit.message)
+
+        if commit_type in CORE_CHANGE_COMMIT_TYPES:
+            priority = 0
+        elif commit_type is None:
+            priority = 1
+        else:
+            priority = FOLLOW_UP_COMMIT_TYPE_PRIORITY.get(commit_type, 1)
+
+        return priority, index
+
+    ordered_items = sorted(enumerate(prepared_commits), key=sort_key)
+    return [prepared_commit for _, prepared_commit in ordered_items]
+
+
 def run(args: Sequence[str] | None = None) -> None:
     """Run the CLI entrypoint with argument normalization."""
     raw_args = list(args) if args is not None else sys.argv[1:]
@@ -341,7 +386,7 @@ def generate_commit_message_for_prompt(
     )
 
 
-def should_fallback_to_status_only(exc: github_copilot.CopilotError) -> bool:
+def should_retry_with_compact_prompt(exc: github_copilot.CopilotError) -> bool:
     message_parts = [str(exc)]
     if isinstance(exc, github_copilot.CopilotHttpError) and exc.detail:
         message_parts.append(exc.detail)
@@ -360,6 +405,7 @@ def should_fallback_to_status_only(exc: github_copilot.CopilotError) -> bool:
         "max prompt tokens",
         "input tokens",
         "prompt tokens",
+        "prompt token count",
     )
     return any(indicator in haystack for indicator in indicators)
 
@@ -379,7 +425,7 @@ def generate_commit_message_for_status(
             http_client_config=http_client_config,
         )
     except github_copilot.CopilotError as exc:
-        if not should_fallback_to_status_only(exc):
+        if not should_retry_with_compact_prompt(exc):
             raise
 
     console.print(
@@ -507,31 +553,65 @@ def request_split_commit_plan(
     http_client_config: github_copilot.HttpClientConfig | None = None,
 ) -> SplitCommitPlan:
     """Request and validate a split-commit plan for the staged patch units."""
-    try:
-        planner_prompt = build_split_plan_prompt(
-            status,
-            patch_units,
-            preferred_commits=preferred_commits,
-            context=context,
-        )
+    planner_system_prompt = load_named_prompt(SPLIT_COMMIT_PLANNER_PROMPT_FILENAME)
+    planner_prompt = build_split_plan_prompt(
+        status,
+        patch_units,
+        preferred_commits=preferred_commits,
+        context=context,
+    )
 
+    try:
         with console.status(
             "[yellow]Planning split commits from [bold]staged hunks[/] ...[/yellow]"
         ):
             response = ask_copilot_with_system_prompt(
-                load_named_prompt(SPLIT_COMMIT_PLANNER_PROMPT_FILENAME),
+                planner_system_prompt,
                 planner_prompt,
                 model=model,
                 http_client_config=http_client_config,
             )
+    except github_copilot.CopilotError as exc:
+        if not should_retry_with_compact_prompt(exc):
+            print_copilot_error("Could not generate a split commit plan", exc)
+            raise typer.Exit(1)
+
+        console.print(
+            "[yellow]Staged patch units exceeded the model context window; retrying split planning with summaries only.[/yellow]"
+        )
+    else:
         return parse_split_plan_response(
             response,
             patch_units,
         )
+
+    compact_planner_prompt = build_split_plan_prompt(
+        status,
+        patch_units,
+        preferred_commits=preferred_commits,
+        context=context,
+        include_patches=False,
+    )
+
+    try:
+        with console.status(
+            "[yellow]Planning split commits from [bold]patch summaries[/] ...[/yellow]"
+        ):
+            response = ask_copilot_with_system_prompt(
+                planner_system_prompt,
+                compact_planner_prompt,
+                model=model,
+                http_client_config=http_client_config,
+            )
     except github_copilot.CopilotError as exc:
         print_copilot_error("Could not generate a split commit plan", exc)
         raise typer.Exit(1)
 
+    return parse_split_plan_response(
+        response,
+        patch_units,
+    )
+
 
 def request_split_commit_messages(
     plan: SplitCommitPlan,
@@ -827,6 +907,7 @@ def handle_split_commit_flow(
         context=context,
         http_client_config=http_client_config,
     )
+    prepared_commits = order_prepared_split_commits(prepared_commits)
 
     if len(prepared_commits) == 1:
         console.print(

{git_copilot_commit-0.5.3 → git_copilot_commit-0.5.5}/src/git_copilot_commit/prompts/split-commit-planner-prompt.md

@@ -15,6 +15,11 @@ small number of coherent commits.
 - Do not split a patch unit further.
 - Preserve the natural order of work. If unit `u1` appears before `u4` in the
   diff, prefer to keep that order within a commit.
+- Order commits the way experienced software developers usually land them:
+  foundational product code first, then tests that validate that code, then
+  docs/examples, then style/chore follow-ups.
+- If a docs or test unit depends on a feat/fix/refactor/perf unit, place the
+  docs or test commit after the underlying code change.
 - If multiple units belong to the same logical change, keep them together.
 - If the staged changes are best represented as a single coherent commit, return
   one commit.

{git_copilot_commit-0.5.3 → git_copilot_commit-0.5.5}/src/git_copilot_commit/split_commits.py

@@ -173,6 +173,7 @@ def build_split_plan_prompt(
     *,
     preferred_commits: int | None = None,
     context: str = "",
+    include_patches: bool = True,
 ) -> str:
     """Build the user prompt used to request a split-commit plan."""
     if not patch_units:
@@ -193,7 +194,7 @@ def build_split_plan_prompt(
             "`git status`:",
             f"```\n{status.get_porcelain_output()}\n```",
             "",
-            "Patch units:",
+            "Patch units:" if include_patches else "Patch units (summaries only):",
         ]
     )
 
@@ -204,10 +205,15 @@ def build_split_plan_prompt(
                 f"Path: {unit.path}",
                 f"Kind: {unit.kind}",
                 f"Summary: {unit.summary}",
-                "Patch:",
-                f"```diff\n{unit.patch}\n```",
             ]
         )
+        if include_patches:
+            prompt_parts.extend(
+                [
+                    "Patch:",
+                    f"```diff\n{unit.patch}\n```",
+                ]
+            )
 
     return "\n".join(prompt_parts)
 

{git_copilot_commit-0.5.3 → git_copilot_commit-0.5.5}/tests/test_cli.py

@@ -15,12 +15,14 @@ from git_copilot_commit.cli import (
     commit_with_retry_no_verify,
     display_selected_model,
     display_split_commit_plan,
+    extract_conventional_commit_type,
     execute_split_commit_plan,
     generate_commit_message_for_status,
     handle_split_commit_flow,
     load_named_prompt,
     load_system_prompt,
     normalize_model_name,
+    order_prepared_split_commits,
     print_copilot_error,
     preprocess_cli_args,
     resolve_prompt_file,
@@ -142,6 +144,70 @@ def test_generate_commit_message_for_status_retries_without_diff_on_context_over
     mock_print.assert_called()
 
 
+def test_request_split_commit_plan_retries_without_patches_on_context_overflow(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    status = GitStatus(
+        files=[
+            GitFile(path="src/example.py", status=" ", staged_status="M"),
+            GitFile(path="README.md", status=" ", staged_status="A"),
+        ],
+        staged_diff=(
+            "diff --git a/src/example.py b/src/example.py\n+print('hi')\n"
+            "diff --git a/README.md b/README.md\n+# hi\n"
+        ),
+        unstaged_diff="",
+    )
+    patch_units = (
+        PatchUnit(
+            id="u1",
+            order=0,
+            path="src/example.py",
+            staged_status="M",
+            kind="hunk",
+            patch="diff --git a/src/example.py b/src/example.py\n+print('hi')\n",
+            summary="src/example.py hunk 1/1 @@ -1 +1 @@ (+1/-0)",
+        ),
+        PatchUnit(
+            id="u2",
+            order=1,
+            path="README.md",
+            staged_status="A",
+            kind="new_file",
+            patch="diff --git a/README.md b/README.md\n+# hi\n",
+            summary="add README.md (+1/-0)",
+        ),
+    )
+    mock_print = Mock()
+    mock_ask = Mock(
+        side_effect=[
+            github_copilot.CopilotHttpError(
+                400,
+                "Bad Request",
+                (
+                    '{"error":{"message":"prompt token count of 1719062 exceeds '
+                    'the limit of 128000","code":"model_max_prompt_tokens_exceeded"}}'
+                ),
+            ),
+            '{"commits":[{"unit_ids":["u1"]},{"unit_ids":["u2"]}]}',
+        ]
+    )
+    monkeypatch.setattr(cli.console, "print", mock_print)
+    monkeypatch.setattr(cli, "load_named_prompt", Mock(return_value="system prompt"))
+    monkeypatch.setattr(cli, "ask_copilot_with_system_prompt", mock_ask)
+
+    plan = cli.request_split_commit_plan(status, patch_units)
+
+    assert [commit.unit_ids for commit in plan.commits] == [("u1",), ("u2",)]
+    assert mock_ask.call_count == 2
+    first_prompt = mock_ask.call_args_list[0].args[1]
+    second_prompt = mock_ask.call_args_list[1].args[1]
+    assert "```diff" in first_prompt
+    assert "```diff" not in second_prompt
+    assert "Patch units (summaries only):" in second_prompt
+    mock_print.assert_called()
+
+
 def test_display_split_commit_plan_shows_files_not_hunk_summaries(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -305,6 +371,36 @@ def test_build_http_client_config_and_normalize_model_name(
     assert normalize_model_name(None) is None
 
 
+def test_extract_conventional_commit_type_supports_scope_and_breaking_change() -> None:
+    assert extract_conventional_commit_type("feat(api): add endpoint") == "feat"
+    assert extract_conventional_commit_type("refactor!: simplify planner") == (
+        "refactor"
+    )
+    assert extract_conventional_commit_type("not a conventional commit") is None
+
+
+def test_order_prepared_split_commits_moves_follow_up_commits_after_core_changes() -> (
+    None
+):
+    prepared_commits = [
+        PreparedSplitCommit(message="docs: update README", patch_units=()),
+        PreparedSplitCommit(message="feat: add split planning", patch_units=()),
+        PreparedSplitCommit(message="test: cover split planning", patch_units=()),
+        PreparedSplitCommit(message="chore: update fixtures", patch_units=()),
+        PreparedSplitCommit(message="fix(parser): preserve ordering", patch_units=()),
+    ]
+
+    ordered = order_prepared_split_commits(prepared_commits)
+
+    assert [prepared_commit.message for prepared_commit in ordered] == [
+        "feat: add split planning",
+        "fix(parser): preserve ordering",
+        "test: cover split planning",
+        "docs: update README",
+        "chore: update fixtures",
+    ]
+
+
 def test_preprocess_cli_args_rewrites_split_syntax() -> None:
     assert preprocess_cli_args(["commit", "--split=auto", "--yes"]) == [
         "commit",
@@ -866,6 +962,81 @@ def test_handle_split_commit_flow_split_limit_can_trigger_split_planning(
     execute_plan.assert_called_once_with(repo, prepared_commits, yes=False)
 
 
+def test_handle_split_commit_flow_reorders_prepared_commits_before_execution(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    status = make_status(
+        staged_diff="diff --git a/src/example.py b/src/example.py\n+print('hi')\n"
+    )
+    repo = Mock()
+    repo.get_staged_diff.return_value = "diff"
+    patch_units = (
+        PatchUnit(
+            id="u1",
+            order=0,
+            path="README.md",
+            staged_status="A",
+            kind="new_file",
+            patch="patch 1",
+            summary="summary 1",
+        ),
+        PatchUnit(
+            id="u2",
+            order=1,
+            path="src/app.py",
+            staged_status="M",
+            kind="hunk",
+            patch="patch 2",
+            summary="summary 2",
+        ),
+        PatchUnit(
+            id="u3",
+            order=2,
+            path="tests/test_app.py",
+            staged_status="M",
+            kind="hunk",
+            patch="patch 3",
+            summary="summary 3",
+        ),
+    )
+    split_plan = SplitCommitPlan(
+        commits=(
+            SplitPlanCommit(("u1",)),
+            SplitPlanCommit(("u2",)),
+            SplitPlanCommit(("u3",)),
+        )
+    )
+    unordered_commits = [
+        PreparedSplitCommit(message="docs: readme", patch_units=(patch_units[0],)),
+        PreparedSplitCommit(message="feat: app", patch_units=(patch_units[1],)),
+        PreparedSplitCommit(message="test: app", patch_units=(patch_units[2],)),
+    ]
+    expected_order = [
+        unordered_commits[1],
+        unordered_commits[2],
+        unordered_commits[0],
+    ]
+    monkeypatch.setattr(cli, "extract_patch_units", lambda _diff: patch_units)
+    monkeypatch.setattr(cli, "request_split_commit_plan", Mock(return_value=split_plan))
+    monkeypatch.setattr(
+        cli, "request_split_commit_messages", Mock(return_value=unordered_commits)
+    )
+    display_plan = Mock()
+    execute_plan = Mock(return_value=["aaaabbbb", "ccccdddd", "eeeeffff"])
+    monkeypatch.setattr(cli, "display_split_commit_plan", display_plan)
+    monkeypatch.setattr(cli, "execute_split_commit_plan", execute_plan)
+    monkeypatch.setattr(cli, "handle_single_commit_flow", Mock())
+
+    handle_split_commit_flow(
+        repo,
+        status,
+        model="gpt-5.4",
+    )
+
+    display_plan.assert_called_once_with(expected_order)
+    execute_plan.assert_called_once_with(repo, expected_order, yes=False)
+
+
 def test_handle_split_commit_flow_prompts_when_plan_exceeds_preference(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:

{git_copilot_commit-0.5.3 → git_copilot_commit-0.5.5}/tests/test_split_commits.py

@@ -99,6 +99,20 @@ def test_build_split_plan_prompt_includes_unit_details() -> None:
     assert "Kind: new_file" in prompt
 
 
+def test_build_split_plan_prompt_can_omit_raw_patches() -> None:
+    units = extract_patch_units(MULTI_FILE_DIFF)
+
+    prompt = build_split_plan_prompt(
+        make_status(),
+        units,
+        include_patches=False,
+    )
+
+    assert "Patch units (summaries only):" in prompt
+    assert "Summary: src/app.py hunk 1/2" in prompt
+    assert "```diff" not in prompt
+
+
 def test_build_split_plan_prompt_supports_preferred_commit_count() -> None:
     units = extract_patch_units(MULTI_FILE_DIFF)