Feat: add repository lock detection and validation

Implement lock handling to prevent Git operations on a locked repository.
- Add `GitCommands.get_repo_lock` to locate an existing `index.lock` via `git rev-parse` and return its path.
- Add `validate_repo_not_locked` utility that raises `GitError` with remediation instructions when a lock file is present.
- Integrate `validate_repo_not_locked` into `validate_git_repository` to abort actions on a locked repo.
- Add comprehensive unit tests for successful validation and for error handling when a repository is locked.

Author: Ademfcan

src/codestory/core/git/git_commands.py

@@ -17,6 +17,8 @@
 # -----------------------------------------------------------------------------
 
 
+from pathlib import Path
+
 from codestory.core.git.git_const import EMPTYTREEHASH
 from codestory.core.git.git_interface import GitInterface
 
@@ -302,6 +304,23 @@ def is_bare_repository(self) -> bool:
         res = self.git.run_git_text_out(["rev-parse", "--is-bare-repository"])
         return res.strip() == "true" if res else False
 
+    def get_repo_lock(self) -> str | None:
+        """Checks if the repository is locked by another git process.
+
+        Returns the path to the lock file if it exists, otherwise None.
+        """
+        # index.lock is the most common git lock.
+        # We use rev-parse --git-path to correctly handle worktrees and submodules.
+        res = self.git.run_git_text_out(["rev-parse", "--git-path", "index.lock"])
+        if res:
+            lock_path = Path(res.strip())
+            # Handle both absolute and relative paths from git
+            if not lock_path.is_absolute():
+                lock_path = self.git.repo_path / lock_path
+            if lock_path.exists():
+                return str(lock_path)
+        return None
+
     def try_get_parent_hash(
         self, commit_hash: str, empty_on_fail: bool = False
     ) -> str | None:

src/codestory/core/validation.py

@@ -261,6 +261,29 @@ def validate_git_repository(git_commands: GitCommands) -> None:
     if not os.path.exists(os.path.join(str(git_commands.git.repo_path), ".git")):
         raise GitError("Not a git repository")
 
+    # Check if the repository is locked
+    validate_repo_not_locked(git_commands)
+
+
+def validate_repo_not_locked(git_commands: GitCommands) -> None:
+    """Validate that the repository is not locked by another git process.
+
+    Args:
+        git_commands: Git commands to run
+
+    Raises:
+        GitError: If the repository is locked
+    """
+    lock_file = git_commands.get_repo_lock()
+    if lock_file:
+        raise GitError(
+            "Another git process seems to be running in this repository, e.g.\n"
+            "an editor opened by 'git commit'. Please make sure all processes\n"
+            "are terminated then try again. If it still fails, a git process\n"
+            "may have crashed in this repository earlier:\n"
+            f"remove the file '{lock_file}' manually to continue."
+        )
+
 
 def validate_default_branch(git_commands: GitCommands) -> None:
     """Validate that we are on a branch (not in detached HEAD state).

src/tests/unit/core/test_validation.py

@@ -91,6 +91,20 @@ def test_validate_git_repository_success(mock_git_commands):
 
     # Should not raise when .git exists
     with patch("os.path.exists", return_value=True):
+        mock_git_commands.get_repo_lock.return_value = None
+        validate_git_repository(mock_git_commands)
+
+
+def test_validate_git_repository_locked(mock_git_commands):
+    mock_git_commands.is_git_repo.return_value = True
+    mock_git_commands.git = Mock()
+    mock_git_commands.git.repo_path = "/fake"
+    mock_git_commands.get_repo_lock.return_value = "/fake/.git/index.lock"
+
+    with (
+        patch("os.path.exists", return_value=True),
+        pytest.raises(GitError, match="Another git process seems to be running"),
+    ):
         validate_git_repository(mock_git_commands)