git-copilot-commit 0.5.4__tar.gz → 0.5.6__tar.gz

{git_copilot_commit-0.5.4 → git_copilot_commit-0.5.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-copilot-commit
-Version: 0.5.4
+Version: 0.5.6
 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.4 → git_copilot_commit-0.5.6}/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:]
@@ -862,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.4 → git_copilot_commit-0.5.6}/src/git_copilot_commit/git.py

@@ -139,7 +139,9 @@ class GitRepository:
         except subprocess.CalledProcessError:
             raise NotAGitRepositoryError(f"{self.cwd} is not a git repository")
         except subprocess.TimeoutExpired:
-            raise GitCommandError("Git command timed out: git rev-parse --show-toplevel")
+            raise GitCommandError(
+                "Git command timed out: git rev-parse --show-toplevel"
+            )
 
         repo_root = result.stdout.strip()
         if not repo_root:
@@ -264,10 +266,18 @@ class GitRepository:
         result = self._run_git_command(["rev-parse", ref])
         return result.stdout.strip()
 
+    def has_commit(self, ref: str = "HEAD") -> bool:
+        """Return whether the provided ref resolves to a commit."""
+        result = self._run_git_command(
+            ["rev-parse", "--verify", "--quiet", f"{ref}^{{commit}}"],
+            check=False,
+        )
+        return result.returncode == 0
+
     def _parse_status_output(self, status_output: str) -> list[GitFile]:
         """Parse git status --porcelain output into GitFile objects."""
         files = []
-        for line in status_output.strip().split("\n"):
+        for line in status_output.splitlines():
             if not line:
                 continue
 
@@ -318,12 +328,13 @@ class GitRepository:
 
     def create_alternate_index(self, from_ref: str = "HEAD") -> AlternateGitIndex:
         """Create a temporary git index initialized from the provided ref."""
-        fd, index_path = tempfile.mkstemp(
-            prefix="git-copilot-commit-", suffix=".index"
-        )
+        fd, index_path = tempfile.mkstemp(prefix="git-copilot-commit-", suffix=".index")
         os.close(fd)
         alternate_index = AlternateGitIndex(Path(index_path))
-        self.read_tree(from_ref, index=alternate_index)
+        if from_ref == "HEAD" and not self.has_commit(from_ref):
+            self.read_empty_tree(index=alternate_index)
+        else:
+            self.read_tree(from_ref, index=alternate_index)
         return alternate_index
 
     @contextmanager
@@ -341,6 +352,10 @@ class GitRepository:
         """Populate an alternate index from the provided ref."""
         self._run_git_command(["read-tree", ref], env=index.env)
 
+    def read_empty_tree(self, *, index: AlternateGitIndex) -> None:
+        """Initialize an alternate index with an empty tree."""
+        self._run_git_command(["read-tree", "--empty"], env=index.env)
+
     def apply_patch(
         self,
         patch: str,

{git_copilot_commit-0.5.4 → git_copilot_commit-0.5.6}/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.4 → git_copilot_commit-0.5.6}/tests/conftest.py

@@ -23,6 +23,9 @@ def git_repo_path(tmp_path: Path) -> Path:
     run_git(tmp_path, "init", "-q")
     run_git(tmp_path, "config", "user.name", "Test User")
     run_git(tmp_path, "config", "user.email", "test@example.com")
+    hooks_dir = tmp_path / ".githooks"
+    hooks_dir.mkdir()
+    run_git(tmp_path, "config", "core.hooksPath", str(hooks_dir))
     return tmp_path
 
 

{git_copilot_commit-0.5.4 → git_copilot_commit-0.5.6}/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,
@@ -369,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",
@@ -640,6 +672,58 @@ def test_execute_split_commit_plan_creates_multiple_commits(
     assert recent_messages == ["chore: update last line", "chore: update first line"]
 
 
+def test_execute_split_commit_plan_supports_initial_commit(
+    git_repo,
+    git_repo_path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(cli.Confirm, "ask", Mock(return_value=True))
+    src_dir = git_repo_path / "src"
+    src_dir.mkdir()
+    app_file = src_dir / "app.lua"
+    readme_file = git_repo_path / "README.md"
+    app_file.write_text("print('hello')\n", encoding="utf-8")
+    readme_file.write_text("# Project\n", encoding="utf-8")
+    git_repo.stage_files(["src/app.lua", "README.md"])
+
+    patch_units = tuple(
+        extract_patch_units(git_repo.get_staged_diff(extra_args=SPLIT_DIFF_ARGS))
+    )
+    assert len(patch_units) == 2
+
+    prepared_commits = [
+        PreparedSplitCommit(
+            message=(
+                f"docs: add {patch_units[0].path}"
+                if patch_units[0].path.endswith(".md")
+                else f"feat: add {patch_units[0].path}"
+            ),
+            patch_units=(patch_units[0],),
+        ),
+        PreparedSplitCommit(
+            message=(
+                f"docs: add {patch_units[1].path}"
+                if patch_units[1].path.endswith(".md")
+                else f"feat: add {patch_units[1].path}"
+            ),
+            patch_units=(patch_units[1],),
+        ),
+    ]
+
+    commit_shas = execute_split_commit_plan(git_repo, prepared_commits, yes=True)
+
+    assert len(commit_shas) == 2
+    final_status = git_repo.get_status()
+    assert not final_status.has_staged_changes
+    assert not final_status.has_unstaged_changes
+
+    recent_messages = [message for _, message in git_repo.get_recent_commits(limit=2)]
+    assert recent_messages == [
+        prepared_commits[1].message,
+        prepared_commits[0].message,
+    ]
+
+
 def test_handle_split_commit_flow_falls_back_to_single_commit(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -930,6 +1014,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.4 → git_copilot_commit-0.5.6}/tests/test_git.py

@@ -99,6 +99,34 @@ def test_alternate_index_commit_preserves_real_index_and_unstaged_changes(
     assert recent_messages == ["part 2", "part 1"]
 
 
+def test_alternate_index_supports_unborn_head(git_repo, git_repo_path) -> None:
+    file_path = git_repo_path / "README.md"
+    file_path.write_text("# Title\n", encoding="utf-8")
+    git_repo.stage_files(["README.md"])
+
+    staged_diff = git_repo.get_staged_diff(
+        extra_args=["--src-prefix=a/", "--dst-prefix=b/"]
+    )
+    assert "new file mode" in staged_diff
+
+    with git_repo.temporary_alternate_index() as alternate_index:
+        git_repo.check_patch_for_alternate_index(staged_diff, index=alternate_index)
+        git_repo.apply_patch_to_alternate_index(staged_diff, index=alternate_index)
+        commit_sha = git_repo.commit(
+            "docs: add readme",
+            env=alternate_index.env,
+            no_verify=True,
+        )
+
+    assert len(commit_sha) == 40
+    assert not alternate_index.path.exists()
+
+    final_status = git_repo.get_status()
+    assert not final_status.has_staged_changes
+    assert not final_status.has_unstaged_changes
+    assert git_repo.get_recent_commits(limit=1)[0][1] == "docs: add readme"
+
+
 def test_git_file_and_status_helper_properties() -> None:
     staged = GitFile(path="staged.py", status=" ", staged_status="M")
     unstaged = GitFile(path="unstaged.py", status="M", staged_status=" ")
@@ -201,3 +229,12 @@ def test_parse_status_output_build_env_and_commit_validation(git_repo) -> None:
 
     with pytest.raises(ValueError):
         git_repo.commit(None)
+
+
+def test_parse_status_output_preserves_leading_space_on_first_line(git_repo) -> None:
+    parsed = git_repo._parse_status_output(" M backend/service.py\nM  frontend.py\n")
+
+    assert [(file.staged_status, file.status, file.path) for file in parsed] == [
+        (" ", "M", "backend/service.py"),
+        ("M", " ", "frontend.py"),
+    ]