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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-copilot-commit
-Version: 0.5.5
+Version: 0.5.7
 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.5 → git_copilot_commit-0.5.7}/src/git_copilot_commit/cli.py

@@ -95,6 +95,14 @@ class PreparedSplitCommit:
     patch_units: tuple[PatchUnit, ...]
 
 
+@dataclass(frozen=True, slots=True)
+class SplitCommitExecutionState:
+    """Original HEAD state used to roll back partial split-commit execution."""
+
+    original_head_sha: str | None
+    original_head_ref: str | None
+
+
 CORE_CHANGE_COMMIT_TYPES = frozenset({"feat", "fix", "perf", "refactor", "revert"})
 FOLLOW_UP_COMMIT_TYPE_PRIORITY = {
     "test": 2,
@@ -757,39 +765,62 @@ def execute_split_commit_plan(
             console.print("Invalid choice. Commit cancelled.")
             raise typer.Exit()
 
+    execution_state = SplitCommitExecutionState(
+        original_head_sha=repo.get_head_sha() if repo.has_commit("HEAD") else None,
+        original_head_ref=repo.get_symbolic_head_ref(),
+    )
     commit_shas: list[str] = []
     total_commits = len(prepared_commits)
 
-    for index, prepared_commit in enumerate(prepared_commits, start=1):
-        console.print(
-            f"[cyan]Creating commit {index}/{total_commits}:[/cyan] {prepared_commit.message}"
-        )
+    try:
+        for index, prepared_commit in enumerate(prepared_commits, start=1):
+            console.print(
+                f"[cyan]Creating commit {index}/{total_commits}:[/cyan] {prepared_commit.message}"
+            )
 
-        with repo.temporary_alternate_index() as alternate_index:
-            try:
-                for patch_unit in prepared_commit.patch_units:
-                    repo.check_patch_for_alternate_index(
-                        patch_unit.patch,
-                        index=alternate_index,
+            with repo.temporary_alternate_index() as alternate_index:
+                try:
+                    for patch_unit in prepared_commit.patch_units:
+                        repo.check_patch_for_alternate_index(
+                            patch_unit.patch,
+                            index=alternate_index,
+                        )
+                        repo.apply_patch_to_alternate_index(
+                            patch_unit.patch,
+                            index=alternate_index,
+                        )
+                except GitError as exc:
+                    console.print(
+                        f"[red]Failed to apply the planned changes for commit {index}: {exc}[/red]"
                     )
-                    repo.apply_patch_to_alternate_index(
-                        patch_unit.patch,
-                        index=alternate_index,
+                    raise typer.Exit(1)
+
+                commit_shas.append(
+                    commit_with_retry_no_verify(
+                        repo,
+                        prepared_commit.message,
+                        use_editor=use_editor,
+                        env=alternate_index.env,
                     )
-            except GitError as exc:
-                console.print(
-                    f"[red]Failed to apply the planned changes for commit {index}: {exc}[/red]"
-                )
-                raise typer.Exit(1)
-
-            commit_shas.append(
-                commit_with_retry_no_verify(
-                    repo,
-                    prepared_commit.message,
-                    use_editor=use_editor,
-                    env=alternate_index.env,
                 )
+    except BaseException:
+        try:
+            if execution_state.original_head_sha is not None:
+                repo.soft_reset(execution_state.original_head_sha)
+            elif execution_state.original_head_ref is not None and repo.has_commit(
+                "HEAD"
+            ):
+                repo.delete_ref(execution_state.original_head_ref)
+        except GitError as exc:
+            console.print(
+                "[red]Failed to restore the original staged changes after split commit creation stopped early: "
+                f"{exc}[/red]"
+            )
+        else:
+            console.print(
+                "[yellow]Split commit creation did not complete; restored the original staged changes.[/yellow]"
             )
+        raise
 
     return commit_shas
 

{git_copilot_commit-0.5.5 → git_copilot_commit-0.5.7}/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,27 @@ 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 get_symbolic_head_ref(self) -> str | None:
+        """Return the symbolic ref for HEAD when attached to a branch."""
+        result = self._run_git_command(["symbolic-ref", "-q", "HEAD"], check=False)
+        if result.returncode != 0:
+            return None
+
+        ref = result.stdout.strip()
+        return ref or None
+
     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
 
@@ -316,14 +335,32 @@ class GitRepository:
         else:
             self._run_git_command(["reset", "HEAD"] + self._normalize_paths(paths))
 
+    def soft_reset(self, ref: str) -> None:
+        """Move HEAD to ref while preserving the working tree and index."""
+        self._run_git_command(["reset", "--soft", ref])
+
+    def delete_ref(self, ref: str, *, missing_ok: bool = False) -> None:
+        """Delete a ref, optionally ignoring missing refs."""
+        result = self._run_git_command(["update-ref", "-d", ref], check=False)
+        if result.returncode == 0 or missing_ok:
+            return
+
+        error_output = result.stderr or result.stdout or ""
+        if error_output:
+            raise GitCommandError(
+                f"Git command failed: git update-ref -d {ref}\n{error_output}"
+            )
+        raise GitCommandError(f"Git command failed: git update-ref -d {ref}")
+
     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 +378,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.5 → git_copilot_commit-0.5.7}/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.5 → git_copilot_commit-0.5.7}/tests/test_cli.py

@@ -672,6 +672,177 @@ 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_rolls_back_partial_commits_on_interrupt(
+    git_repo,
+    git_repo_path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(cli.Confirm, "ask", Mock(return_value=True))
+    file_path = git_repo_path / "file.txt"
+    file_path.write_text("a\nb\nc\nd\ne\nf\ng\nh\ni\nj\n", encoding="utf-8")
+    git_repo.stage_files(["file.txt"])
+    git_repo.commit("init", no_verify=True)
+
+    file_path.write_text("A\nb\nc\nd\ne\nf\ng\nh\ni\nJ\n", encoding="utf-8")
+    git_repo.stage_files(["file.txt"])
+    file_path.write_text("A\nbb\nc\nd\ne\nf\ng\nhh\ni\nJ\nextra\n", encoding="utf-8")
+    original_status = git_repo.get_status()
+
+    patch_units = tuple(
+        extract_patch_units(git_repo.get_staged_diff(extra_args=SPLIT_DIFF_ARGS))
+    )
+    prepared_commits = [
+        PreparedSplitCommit(
+            message="chore: update first line",
+            patch_units=(patch_units[0],),
+        ),
+        PreparedSplitCommit(
+            message="chore: update last line",
+            patch_units=(patch_units[1],),
+        ),
+    ]
+
+    commit_attempts = 0
+
+    def interrupting_commit(repo, message, use_editor=False, env=None):
+        nonlocal commit_attempts
+        commit_attempts += 1
+        if commit_attempts == 2:
+            raise KeyboardInterrupt()
+
+        return commit_with_retry_no_verify(
+            repo,
+            message,
+            use_editor=use_editor,
+            env=env,
+        )
+
+    monkeypatch.setattr(cli, "commit_with_retry_no_verify", interrupting_commit)
+
+    with pytest.raises(KeyboardInterrupt):
+        execute_split_commit_plan(git_repo, prepared_commits, yes=True)
+
+    final_status = git_repo.get_status()
+    assert final_status.staged_diff == original_status.staged_diff
+    assert final_status.unstaged_diff == original_status.unstaged_diff
+    assert git_repo.get_recent_commits(limit=1)[0][1] == "init"
+
+
+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_execute_split_commit_plan_rolls_back_partial_initial_commits_on_interrupt(
+    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"])
+    original_status = git_repo.get_status()
+
+    patch_units = tuple(
+        extract_patch_units(git_repo.get_staged_diff(extra_args=SPLIT_DIFF_ARGS))
+    )
+    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_attempts = 0
+
+    def interrupting_commit(repo, message, use_editor=False, env=None):
+        nonlocal commit_attempts
+        commit_attempts += 1
+        if commit_attempts == 2:
+            raise KeyboardInterrupt()
+
+        return commit_with_retry_no_verify(
+            repo,
+            message,
+            use_editor=use_editor,
+            env=env,
+        )
+
+    monkeypatch.setattr(cli, "commit_with_retry_no_verify", interrupting_commit)
+
+    with pytest.raises(KeyboardInterrupt):
+        execute_split_commit_plan(git_repo, prepared_commits, yes=True)
+
+    final_status = git_repo.get_status()
+    assert final_status.staged_diff == original_status.staged_diff
+    assert final_status.unstaged_diff == original_status.unstaged_diff
+    assert not git_repo.has_commit("HEAD")
+
+
 def test_handle_split_commit_flow_falls_back_to_single_commit(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:

{git_copilot_commit-0.5.5 → git_copilot_commit-0.5.7}/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"),
+    ]