git2svn 0.4.1__tar.gz → 0.5.1__tar.gz

{git2svn-0.4.1 → git2svn-0.5.1}/.github/workflows/ci.yml

@@ -65,7 +65,9 @@ jobs:
           echo "C:\Program Files\TortoiseSVN\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
 
       - name: Install Dependencies
-        run: pip install -e .[dev]
+        run: |
+          python -m pip install --upgrade pip setuptools wheel
+          pip install --retries 5 -e .[dev]
 
       - name: Run Unit & Integration Tests (with Coverage)
         if: runner.os == 'Linux' && matrix.python-version == '3.12'

{git2svn-0.4.1/git2svn.egg-info → git2svn-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git2svn
-Version: 0.4.1
+Version: 0.5.1
 Summary: CLI utility to synchronize changes from a local Git repository to a local SVN working copy
 Author: Simon
 License: Apache-2.0
@@ -35,7 +35,7 @@ Dynamic: license-file
 <p align="center">
   <a href="https://github.com/simon123h/git2svn/actions/workflows/ci.yml"><img src="https://github.com/simon123h/git2svn/actions/workflows/ci.yml/badge.svg?branch=main" alt="Build Status"></a>
   <a href="https://codecov.io/gh/simon123h/git2svn"><img src="https://codecov.io/gh/simon123h/git2svn/branch/main/graph/badge.svg" alt="Coverage"></a>
-  <a href="https://pypi.org/project/git2svn/"><img src="https://img.shields.io/pypi/v/git2svn?color=blue" alt="PyPI Version"></a>
+  <a href="https://pypi.org/project/git2svn/"><img src="https://img.shields.io/pypi/v/git2svn?color=green" alt="PyPI Version"></a>
   <img src="https://img.shields.io/badge/Python-v3.11+-3776AB?logo=python&logoColor=white" alt="Python Version">
   <img src="https://img.shields.io/endpoint?url=https%3A%2F%2Ftokei.kojix2.net%2Fbadge%2Fgithub%2Fsimon123h%2Fgit2svn%2Flines" alt="Lines of Code">
   <a href="https://github.com/simon123h/git2svn/releases"><img src="https://badgen.net/github/release/simon123h/git2svn?color=orange" alt="Latest Release"></a>

{git2svn-0.4.1 → git2svn-0.5.1}/README.md

@@ -3,7 +3,7 @@
 <p align="center">
   <a href="https://github.com/simon123h/git2svn/actions/workflows/ci.yml"><img src="https://github.com/simon123h/git2svn/actions/workflows/ci.yml/badge.svg?branch=main" alt="Build Status"></a>
   <a href="https://codecov.io/gh/simon123h/git2svn"><img src="https://codecov.io/gh/simon123h/git2svn/branch/main/graph/badge.svg" alt="Coverage"></a>
-  <a href="https://pypi.org/project/git2svn/"><img src="https://img.shields.io/pypi/v/git2svn?color=blue" alt="PyPI Version"></a>
+  <a href="https://pypi.org/project/git2svn/"><img src="https://img.shields.io/pypi/v/git2svn?color=green" alt="PyPI Version"></a>
   <img src="https://img.shields.io/badge/Python-v3.11+-3776AB?logo=python&logoColor=white" alt="Python Version">
   <img src="https://img.shields.io/endpoint?url=https%3A%2F%2Ftokei.kojix2.net%2Fbadge%2Fgithub%2Fsimon123h%2Fgit2svn%2Flines" alt="Lines of Code">
   <a href="https://github.com/simon123h/git2svn/releases"><img src="https://badgen.net/github/release/simon123h/git2svn?color=orange" alt="Latest Release"></a>

{git2svn-0.4.1 → git2svn-0.5.1}/docs/arc42/adrs.md

@@ -73,3 +73,15 @@ This document contains the Architecture Decision Records (ADRs) for `git2svn`.
 * **Context:** Subversion's mixed-revision working copy design leaves the local root revision behind `HEAD` after commits, hiding new revisions from `svn log` until `svn update` is run.
 * **Decision:** Provide an opt-in `-u` / `--update` flag and `git2svn.autoUpdate` setting to trigger `svn update` upon successful replay completion.
 * **Consequences:** Keeps local working copy base at `HEAD` while allowing users on massive remote SVN repositories to avoid extra network latency.
+
+---
+
+### ADR-11: No Author/Metadata Preservation or Date Spoofing
+* **Context:** In Git, commits carry distinct author and committer names, emails, and historical timestamps. Subversion tracks revision properties (`svn:author`, `svn:date`) which are either immutable by default or require custom server-side hook scripts (`pre-revprop-change`) that are typically locked down in enterprise SVN deployments. Modifying revision properties or spoofing commit timestamps/authors can create security, audit, and traceability concerns, in addition to introducing server-dependent replay failures.
+* **Decision:** Explicitly reject author spoofing, date manipulation, or artificial metadata rewriting in `git2svn`. All replayed commits are committed using the active SVN working copy user credentials and the current server timestamp. Original Git commit messages are preserved verbatim, but author identity and commit time in SVN remain authoritative to the person running the tool at the time of execution.
+* **Consequences:**
+  - Guarantees compatibility with all SVN servers out of the box without requiring `pre-revprop-change` server hook privileges.
+  - Maintains strict organizational accountability: the committer who pushes the changes to SVN is always the verified SVN user.
+  - Avoids temporal inconsistencies in SVN repositories where revisions must strictly increase in time.
+  - Keeps the codebase lightweight and free of brittle revision-property manipulation logic.
+

{git2svn-0.4.1 → git2svn-0.5.1}/docs/user-guide/commands.md

@@ -153,10 +153,31 @@ git2svn setup /path/to/svn
 5. **Configures Safe Productivity Aliases:**
    - `git config alias.svn-push`: Replays trunk to SVN, fetches SVN mirror, and safely resets trunk *only* if `trunk` matches `svn-mirror/trunk` (guarded by `git diff --quiet`).
    - `git config alias.svn-pull`: Fetches SVN mirror, fast-forwards trunk if clean, and automatically rebases local commits if unpushed work exists on trunk.
+   - `git config alias.svn-status`: Inspects synchronization health, pending commits, and workspace state via `git2svn status`.
 
 ---
 
-## 5. Structural Staging Mechanics
+## 5. Command: `status`
+
+Inspects synchronization health, pending commits in `git2svn.defaultRange`, and working tree states across both Git and Subversion.
+
+```bash
+git2svn status
+```
+
+### What `status` reports:
+- **Git Workspace:** Active branch, latest commit hash & subject, and working tree cleanliness.
+- **SVN Working Copy:** Path, target SVN URL, base revision, cleanliness, and lock status.
+- **Synchronization Queue:** Configured `git2svn.defaultRange`, pending commit count & titles, and linear history validation (warns if merge commits exist).
+- **In-Progress Replay:** State of paused replays (if a conflict occurred), remaining commits, active `.rej` conflict files, and actionable recovery commands (`--continue`, `--abort`, `--skip`).
+
+### Exit Codes:
+- `0`: Workspace is clean, unlocked, and synchronization queue is valid.
+- `1`: SVN working copy is locked/dirty, replay is paused due to conflict, or merge commits violate linear history.
+
+---
+
+## 6. Structural Staging Mechanics
 
 During patch application or file copying, `git2svn` maps Git status codes (`git diff --name-status`) to the corresponding Subversion commands:
 

{git2svn-0.4.1 → git2svn-0.5.1}/docs/user-guide/integration-workflow.md

@@ -114,6 +114,9 @@ git config alias.svn-pull "!f() { \
         git rebase svn-mirror/trunk; \
     fi; \
 }; f"
+
+# 3. git svn-status: Inspects sync health, pending commits, and working tree states
+git config alias.svn-status "!git2svn status"
 ```
 
 ### Safety Features of These Aliases:
@@ -124,6 +127,9 @@ git config alias.svn-pull "!f() { \
 With these aliases configured alongside `git config git2svn.defaultRange "svn-mirror/trunk..trunk"`:
 
 ```bash
+# Check synchronization health, tree states, and pending commits:
+git svn-status
+
 # Pull latest SVN state into local Git trunk (fast-forward or rebase):
 git svn-pull
 

{git2svn-0.4.1 → git2svn-0.5.1}/docs/user-guide/troubleshooting.md

@@ -53,3 +53,33 @@ git2svn replay -u <range>
 # Or configure globally:
 git config git2svn.autoUpdate true
 ```
+
+---
+
+### Q: Why does `git2svn` fail with "Subversion working copy is locked" (`E155004`)?
+If Subversion was interrupted mid-operation (e.g. an aborted command, an IDE indexing run, or a background mirror sync), Subversion places lock files in `.svn` to prevent database corruption.
+
+To resolve:
+1. Run:
+   ```bash
+   svn cleanup /path/to/svn
+   ```
+2. If background sync scripts or IDE indexing processes are actively touching the directory, wait for them to finish.
+3. Re-run your `git2svn` command.
+
+---
+
+### Q: Why does `git2svn` fail with "Item is out of date" or collision (`E155015` / `E160024`)?
+This happens when another developer or automated process committed new revisions to Subversion upstream while your local working copy was still at an older revision. Subversion rejects committing against stale base revisions.
+
+To resolve:
+1. Update your SVN working copy to bring it up to HEAD:
+   ```bash
+   svn update /path/to/svn
+   ```
+2. Check `svn status` to verify there are no tree or content conflicts.
+3. If an in-progress replay was paused, continue it with:
+   ```bash
+   git2svn replay --continue
+   ```
+

{git2svn-0.4.1 → git2svn-0.5.1}/git2svn/__init__.py

@@ -17,7 +17,7 @@ from .state import (
     load_replay_state,
     save_replay_state,
 )
-from .svn import SvnWorkspace
+from .svn import SvnError, SvnLockError, SvnOutOfDateError, SvnWorkspace
 
 try:
     from ._version import __version__
@@ -39,6 +39,9 @@ __all__ = [
     "Synchronizer",
     "GitRepo",
     "SvnWorkspace",
+    "SvnError",
+    "SvnLockError",
+    "SvnOutOfDateError",
     "Patcher",
     "FileChange",
     "parse_ref_arguments",

{git2svn-0.4.1 → git2svn-0.5.1}/git2svn/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.4.1'
-__version_tuple__ = version_tuple = (0, 4, 1)
+__version__ = version = '0.5.1'
+__version_tuple__ = version_tuple = (0, 5, 1)
 
 __commit_id__ = commit_id = None

{git2svn-0.4.1 → git2svn-0.5.1}/git2svn/cli.py

@@ -12,7 +12,7 @@ from .core import Synchronizer
 from .git import GitRepo
 from .patcher import Patcher
 from .state import load_replay_state
-from .svn import SvnWorkspace
+from .svn import SvnError, SvnLockError, SvnOutOfDateError, SvnWorkspace
 
 logger = logging.getLogger("git2svn")
 
@@ -195,7 +195,7 @@ def build_parser() -> argparse.ArgumentParser:
             "Configure repository settings for git2svn on a fresh clone.\n"
             "Automatically detects local trunk and remote SVN mirror tracking branches,\n"
             "sets git2svn.svnDir, git2svn.defaultRange, git2svn.autoUpdate, pull.ff only,\n"
-            "and configures git alias.svn-push and alias.svn-pull."
+            "and configures git alias.svn-push, alias.svn-pull, and alias.svn-status."
         ),
     )
     parser_setup.add_argument(
@@ -207,6 +207,17 @@ def build_parser() -> argparse.ArgumentParser:
         help="Path to SVN working copy (optional if already configured or set via --svn-dir)",
     )
 
+    # status
+    subparsers.add_parser(
+        "status",
+        parents=[common_parser],
+        help="Inspect synchronization health, pending commits, and workspace state",
+        description=(
+            "Display current state of Git repository, SVN working copy, in-progress replay,\n"
+            "and pending commits in the configured defaultRange."
+        ),
+    )
+
     return parser
 
 
@@ -315,9 +326,11 @@ def handle_setup(git_repo: GitRepo, svn_dir_path: Optional[Path | str]) -> int:
         f"echo '[git svn-pull] Fast-forward not possible (local commits on {trunk_name}). Rebasing onto {mirror_branch}...'; "
         f"git rebase {mirror_branch}; fi; }}; f"
     )
+    status_script = "!git2svn status"
 
     git_repo.set_config("alias.svn-push", push_script)
     git_repo.set_config("alias.svn-pull", pull_script)
+    git_repo.set_config("alias.svn-status", status_script)
 
     print("Successfully configured git2svn:")
     print(f"  git2svn.svnDir      = {svn_dir_str}")
@@ -328,6 +341,7 @@ def handle_setup(git_repo: GitRepo, svn_dir_path: Optional[Path | str]) -> int:
     print("  pull.ff             = only")
     print(f"  alias.svn-push      = {push_script}")
     print(f"  alias.svn-pull      = {pull_script}")
+    print(f"  alias.svn-status    = {status_script}")
     return 0
 
 
@@ -425,7 +439,7 @@ def main(argv: Optional[List[str]] = None) -> int:
     sync_mgr = Synchronizer(git_repo, svn_workspace, patcher, dry_run=dry_run, auto_update=auto_update)
 
     # Fallback to git2svn.defaultRange if ref1 is omitted
-    ref1 = args.ref1
+    ref1 = getattr(args, "ref1", None)
     ref2 = getattr(args, "ref2", None)
     if not ref1 and args.command in ("stage", "replay"):
         # Replay actions (--continue, --abort, --skip) do not need ref1
@@ -470,8 +484,16 @@ def main(argv: Optional[List[str]] = None) -> int:
                     )
                     return 1
                 sync_mgr.replay(ref1, ref2)
+        elif args.command == "status":
+            return sync_mgr.status()
         else:
             return 1
+    except (SvnLockError, SvnOutOfDateError) as e:
+        print(f"\n[SVN Error] {e}", file=sys.stderr)
+        return e.returncode
+    except SvnError as e:
+        print(f"\n[SVN Error] {e}", file=sys.stderr)
+        return e.returncode
     except subprocess.CalledProcessError as e:
         logger.error("Process failed with returncode %s", e.returncode)
         return e.returncode

{git2svn-0.4.1 → git2svn-0.5.1}/git2svn/core.py

@@ -17,7 +17,7 @@ from .state import (
     load_replay_state,
     save_replay_state,
 )
-from .svn import SvnWorkspace
+from .svn import SvnError, SvnWorkspace
 
 logger = logging.getLogger("git2svn")
 
@@ -261,13 +261,23 @@ class Synchronizer:
             )
 
         # 2. Commit the resolved changes for the interrupted commit
+        pad_width = len(str(total))
+        first_line = current_msg.splitlines()[0] if current_msg else ""
+        progress_prefix = f"[{completed + 1:>{pad_width}}/{total}] Resolving {current_commit[:8]}: {first_line}"
+
         if not self.svn.is_clean():
             logger.info("Committing resolved commit %s to SVN...", current_commit)
+            sys.stdout.write(f"{progress_prefix}... ")
+            sys.stdout.flush()
             self.svn.commit(current_msg)
+            sys.stdout.write("OK\n")
+            sys.stdout.flush()
         else:
             logger.info(
                 "No changes in SVN workspace to commit for %s (commit resolved as empty or skipped).", current_commit
             )
+            sys.stdout.write(f"{progress_prefix}... SKIPPED (no changes)\n")
+            sys.stdout.flush()
 
         completed += 1
         logger.info("Commit %s (%d/%d) resolved and committed.", current_commit, completed, total)
@@ -319,15 +329,35 @@ class Synchronizer:
 
     def _execute_replay_queue(self, commits: List[str], total_commits: int, start_index: int) -> None:
         """Execute a list of commits sequentially, catching conflicts and persisting state."""
+        pad_width = len(str(total_commits))
         for idx, commit_hash in enumerate(commits, start=start_index):
             commit_msg = self.git.get_commit_message(commit_hash)
             first_line = commit_msg.splitlines()[0] if commit_msg else ""
-            logger.info("[%d/%d] Applying commit %s: %s", idx, total_commits, commit_hash[:8], first_line)
+            progress_prefix = f"[{idx:>{pad_width}}/{total_commits}] Applying {commit_hash[:8]}: {first_line}"
+            logger.info(progress_prefix)
+
+            # Interactive console progress output
+            if sys.stdout.isatty():
+                sys.stdout.write(f"\r\033[K{progress_prefix}... ")
+                sys.stdout.flush()
+            else:
+                sys.stdout.write(f"{progress_prefix}... ")
+                sys.stdout.flush()
 
             try:
                 self._patch_and_stage_commit(commit_hash)
                 self.svn.commit(commit_msg)
+                sys.stdout.write("OK\n")
+                sys.stdout.flush()
+            except SvnError:
+                sys.stdout.write("FAILED (SVN error)\n")
+                sys.stdout.flush()
+                # SVN operational failure (e.g. working copy locked, out-of-date, collision)
+                # Re-raise directly to display actionable SVN resolution hints
+                raise
             except Exception:
+                sys.stdout.write("CONFLICT\n")
+                sys.stdout.flush()
                 remaining = commits[idx - start_index + 1 :]
                 state_data = {
                     "state": "CONFLICT_PAUSED",
@@ -483,3 +513,121 @@ class Synchronizer:
                     print(f"[DRY-RUN] Ensure directory exists: {target_file.parent}")
                 else:
                     target_file.parent.mkdir(parents=True, exist_ok=True)
+
+    def status(self) -> int:
+        """
+        Inspect and display status of Git repo, SVN working copy, in-progress replay, and pending commits.
+        Returns:
+            0 if clean and ready / in sync
+            1 if errors, working copy locked, merge conflicts, or linear violations exist
+        """
+        has_error = False
+
+        # 1. Check in-progress replay state
+        state = load_replay_state(self.svn.workspace_dir)
+        if state:
+            has_error = True
+            current_commit = state.get("current_commit", "unknown")
+            current_msg = state.get("current_commit_msg", "")
+            first_msg = current_msg.splitlines()[0] if current_msg else ""
+            remaining = state.get("remaining_commits", [])
+            completed = state.get("completed_commits", 0)
+            total = state.get("total_commits", len(remaining) + 1)
+
+            print("[Replay In Progress]")
+            print(f'  State     : PAUSED (conflict at commit {current_commit[:8]} "{first_msg}")')
+            print(f"  Progress  : {completed} of {total} commits applied ({len(remaining)} remaining)")
+
+            rej_files = find_conflict_artifacts(self.svn.workspace_dir)
+            if rej_files:
+                rel_rejs = [str(r.relative_to(self.svn.workspace_dir)) for r in rej_files]
+                print(f"  Conflicts : {', '.join(rel_rejs)}")
+            print("  Action    : Resolve conflicts and run 'git2svn replay --continue' (or '--abort' / '--skip')\n")
+
+        # 2. Git Workspace Status
+        git_clean = self.git.is_clean()
+        branch = self.git.get_current_branch()
+        head_commit = self.git.get_head_commit()
+        head_subject = self.git.get_head_subject()
+        head_desc = f'{head_commit} "{head_subject}"' if head_subject else head_commit
+
+        print("[Git Workspace]")
+        print(f"  Repository: {self.git.repo_dir}")
+        print(f"  Branch    : {branch} (at {head_desc})")
+        print(f"  Tree      : {'Clean' if git_clean else 'Dirty (uncommitted changes present)'}")
+
+        # 3. SVN Working Copy Status
+        print("\n[SVN Working Copy]")
+        print(f"  Path      : {self.svn.workspace_dir}")
+        svn_info = self.svn.get_info()
+        svn_url = svn_info.get("URL") or svn_info.get("Relative URL") or "unknown"
+        svn_rev = svn_info.get("Revision")
+        rev_str = f" (r{svn_rev})" if svn_rev else ""
+        print(f"  Target    : {svn_url}{rev_str}")
+
+        try:
+            svn_clean = self.svn.is_clean()
+            if svn_clean:
+                print("  Tree      : Clean (no uncommitted changes, unlocked)")
+            else:
+                uncommitted = self.svn.get_status_summary()
+                print(f"  Tree      : Dirty ({len(uncommitted)} uncommitted changes)")
+                for item in uncommitted[:5]:
+                    print(f"              {item}")
+                if len(uncommitted) > 5:
+                    print(f"              ... and {len(uncommitted) - 5} more")
+        except SvnError as e:
+            has_error = True
+            print(f"  Tree      : Error: {e.args[0].splitlines()[0]}")
+
+        # 4. Synchronization Queue & Default Range
+        default_range = self.git.get_config("git2svn.defaultRange")
+        print("\n[Synchronization]")
+        if not default_range:
+            print("  Range     : Not configured (run 'git2svn setup' or 'git config git2svn.defaultRange <range>')")
+        else:
+            print(f"  Range     : {default_range}")
+            try:
+                is_single, start_ref, end_ref = parse_ref_arguments(default_range)
+                if is_single:
+                    commits = [start_ref] if self.git.ref_exists(start_ref) else []
+                    merges = []
+                else:
+                    assert end_ref is not None
+                    if not self.git.ref_exists(start_ref):
+                        print(f"  Warning   : Range start ref '{start_ref}' not found in Git.")
+                        commits = []
+                        merges = []
+                    elif not self.git.ref_exists(end_ref):
+                        print(f"  Warning   : Range end ref '{end_ref}' not found in Git.")
+                        commits = []
+                        merges = []
+                    else:
+                        merges = self.git.get_merge_commits(start_ref, end_ref)
+                        commits = self.git.get_commit_range(start_ref, end_ref)
+
+                if merges:
+                    has_error = True
+                    print(
+                        f"  Linearity : INVALID ({len(merges)} merge commits found in range - linear rebase required)"
+                    )
+                else:
+                    print("  Linearity : OK (strictly linear)")
+
+                if not commits:
+                    print("  Pending   : In sync (0 commits to replay)")
+                else:
+                    print(f"  Pending   : {len(commits)} commit(s) ready to replay:")
+                    for idx, c_hash in enumerate(commits[:10], start=1):
+                        msg = self.git.get_commit_message(c_hash)
+                        subject = msg.splitlines()[0] if msg else ""
+                        print(f"              {idx}. [{c_hash[:8]}] {subject}")
+                    if len(commits) > 10:
+                        print(f"              ... and {len(commits) - 10} more")
+            except Exception as e:
+                print(f"  Error     : Could not parse range '{default_range}': {e}")
+                has_error = True
+
+        if has_error:
+            return 1
+        return 0

{git2svn-0.4.1 → git2svn-0.5.1}/git2svn/git.py

@@ -187,6 +187,11 @@ class GitRepo:
             return branch if branch != "HEAD" else "HEAD (detached)"
         return "unknown"
 
+    def is_clean(self) -> bool:
+        """Check if Git working tree and index have no uncommitted changes."""
+        res = self.run_cmd(["status", "--porcelain"], check=False)
+        return not bool(res.stdout.strip())
+
     def get_head_commit(self) -> str:
         """Return the short hash of HEAD."""
         res = self.run_cmd(["rev-parse", "--short", "HEAD"], check=False)
@@ -194,6 +199,18 @@ class GitRepo:
             return res.stdout.strip()
         return "unknown"
 
+    def get_head_subject(self) -> str:
+        """Return the subject line of the HEAD commit."""
+        res = self.run_cmd(["log", "-1", "--format=%s", "HEAD"], check=False)
+        if res.returncode == 0:
+            return res.stdout.strip()
+        return ""
+
+    def ref_exists(self, ref: str) -> bool:
+        """Check whether a Git reference or revision expression resolves."""
+        res = self.run_cmd(["rev-parse", "--verify", "--quiet", ref], check=False)
+        return res.returncode == 0
+
     def get_commit_parent(self, commit_hash: str) -> Optional[str]:
         """Return the parent commit hash, or None if root commit."""
         res = self.run_cmd(["rev-parse", "--verify", f"{commit_hash}^"], check=False)
@@ -201,15 +218,15 @@ class GitRepo:
             return res.stdout.strip()
         return None
 
-    def get_diff(self, ref_spec: str) -> str:
-        """Get unified diff for the given reference specification."""
-        res = self.run_cmd(["diff", "--binary", ref_spec])
+    def get_diff(self, ref_spec: str) -> bytes:
+        """Get unified diff for the given reference specification as raw bytes."""
+        res = self.run_cmd_bytes(["diff", "--binary", ref_spec])
         return res.stdout
 
-    def get_diff_root(self, commit_hash: str) -> str:
-        """Get unified diff for a root commit."""
+    def get_diff_root(self, commit_hash: str) -> bytes:
+        """Get unified diff for a root commit as raw bytes."""
         empty_tree_hash = "4b825dc642cb6eb9a060e54bf8d69288fbee4904"
-        res = self.run_cmd(["diff", "--binary", empty_tree_hash, commit_hash])
+        res = self.run_cmd_bytes(["diff", "--binary", empty_tree_hash, commit_hash])
         return res.stdout
 
     def get_name_status(self, ref_spec: str) -> List[FileChange]:

{git2svn-0.4.1 → git2svn-0.5.1}/git2svn/patcher.py

@@ -4,6 +4,7 @@ import logging
 import subprocess
 import sys
 from pathlib import Path
+from typing import Union
 
 logger = logging.getLogger("git2svn")
 
@@ -16,43 +17,49 @@ class Patcher:
         self.git_bin = git_bin
         self.dry_run = dry_run
 
-    def apply_diff(self, diff_content: str) -> None:
-        """Apply unified diff text to target_dir using git apply."""
-        if not diff_content.strip():
+    def apply_diff(self, diff_content: Union[str, bytes]) -> None:
+        """Apply unified diff text or bytes to target_dir using git apply."""
+        if isinstance(diff_content, str):
+            diff_bytes = diff_content.encode("utf-8")
+        else:
+            diff_bytes = diff_content
+
+        if not diff_bytes.strip():
             logger.info("Diff is empty. Nothing to patch.")
             return
 
         cmd = [self.git_bin, "apply", "--ignore-whitespace", "--unsafe-paths", "--reject"]
         if self.dry_run:
-            print(f"[DRY-RUN] (in {self.target_dir}) {' '.join(cmd)} << EOF\n{diff_content.strip()[:200]}...\nEOF")
+            preview = diff_bytes.strip()[:200].decode("utf-8", errors="replace")
+            print(f"[DRY-RUN] (in {self.target_dir}) {' '.join(cmd)} << EOF\n{preview}...\nEOF")
             return
 
         logger.debug("Applying patch to %s using %s", self.target_dir, " ".join(cmd))
         proc = subprocess.run(
             cmd,
             cwd=self.target_dir,
-            input=diff_content,
+            input=diff_bytes,
             capture_output=True,
-            text=True,
-            encoding="utf-8",
-            errors="replace",
         )
 
+        stdout_str = proc.stdout.decode("utf-8", errors="replace") if proc.stdout else ""
+        stderr_str = proc.stderr.decode("utf-8", errors="replace") if proc.stderr else ""
+
         if proc.returncode != 0:
             logger.error(
-                "git apply failed with code %d:\nSTDOUT:\n%s\nSTDERR:\n%s", proc.returncode, proc.stdout, proc.stderr
+                "git apply failed with code %d:\nSTDOUT:\n%s\nSTDERR:\n%s", proc.returncode, stdout_str, stderr_str
             )
             print(f"Error: git apply failed (exit code {proc.returncode}).", file=sys.stderr)
-            if proc.stdout:
-                print(proc.stdout, file=sys.stderr)
-            if proc.stderr:
-                print(proc.stderr, file=sys.stderr)
+            if stdout_str:
+                print(stdout_str, file=sys.stderr)
+            if stderr_str:
+                print(stderr_str, file=sys.stderr)
             print(
                 "Tip: Check for .rej reject files in the SVN workspace or use 'git2svn stage --copy' to copy files directly.",
                 file=sys.stderr,
             )
-            raise subprocess.CalledProcessError(proc.returncode, cmd, proc.stdout, proc.stderr)
+            raise subprocess.CalledProcessError(proc.returncode, cmd, stdout_str, stderr_str)
         else:
-            if proc.stdout or proc.stderr:
-                msg = (proc.stdout + "\n" + proc.stderr).strip()
+            if stdout_str or stderr_str:
+                msg = (stdout_str + "\n" + stderr_str).strip()
                 logger.info("Patch applied successfully:\n%s", msg)

{git2svn-0.4.1 → git2svn-0.5.1}/git2svn/svn.py

@@ -32,6 +32,72 @@ def find_svn_binary() -> str:
     return "svn"
 
 
+class SvnError(RuntimeError):
+    """Base exception for Subversion command failures."""
+
+    def __init__(self, message: str, stderr: str = "", returncode: int = 1):
+        super().__init__(message)
+        self.stderr = stderr
+        self.returncode = returncode
+
+
+class SvnLockError(SvnError):
+    """Raised when the SVN working copy or a file is locked (e.g. E155004)."""
+
+    pass
+
+
+class SvnOutOfDateError(SvnError):
+    """Raised when an SVN commit or update fails due to out-of-date items or collision (e.g. E155015 / E160024)."""
+
+    pass
+
+
+def parse_svn_error(stderr: str, action_desc: str, svn_dir: Path) -> SvnError:
+    """Analyze Subversion stderr and construct actionable SvnError with cleanup hints."""
+    lower_err = stderr.lower()
+    clean_stderr = stderr.strip()
+
+    # 1. Working copy locked (E155004 / "is already locked" / "run 'svn cleanup'")
+    if (
+        "e155004" in lower_err
+        or "working copy locked" in lower_err
+        or "already locked" in lower_err
+        or "run 'svn cleanup'" in lower_err
+    ):
+        hint = (
+            f"Subversion working copy at '{svn_dir}' is locked.\n"
+            f"Details from SVN:\n  {clean_stderr}\n\n"
+            f"To resolve:\n"
+            f'  1. Run: svn cleanup "{svn_dir}"\n'
+            f"  2. If a background process (IDE, mirror sync, indexing) is running, wait for it to finish.\n"
+            f"  3. Retry your git2svn command."
+        )
+        return SvnLockError(hint, stderr=clean_stderr)
+
+    # 2. Out of date / collision (E155015 / E160024 / E155011 / "out of date" / "item is out of date")
+    if (
+        "e155015" in lower_err
+        or "e160024" in lower_err
+        or "e155011" in lower_err
+        or "out of date" in lower_err
+        or "conflict" in lower_err
+    ):
+        hint = (
+            f"Subversion working copy at '{svn_dir}' is out of date or conflicted.\n"
+            f"Details from SVN:\n  {clean_stderr}\n\n"
+            f"To resolve:\n"
+            f'  1. Run: svn update "{svn_dir}"\n'
+            f"  2. Resolve any SVN conflicts if present ('svn status').\n"
+            f"  3. Retry your git2svn command (e.g. 'git2svn replay --continue' or retry replay)."
+        )
+        return SvnOutOfDateError(hint, stderr=clean_stderr)
+
+    # Generic SVN error with context
+    msg = f"Failed to {action_desc} in '{svn_dir}':\n  {clean_stderr}"
+    return SvnError(msg, stderr=clean_stderr)
+
+
 class SvnWorkspace:
     """Wrapper around SVN commands and filesystem staging operations."""
 
@@ -83,8 +149,17 @@ class SvnWorkspace:
     def is_clean(self) -> bool:
         """Check if SVN workspace has no uncommitted changes."""
         res = self.run_cmd(["status", "-q"], check=False)
+        if res.returncode != 0:
+            raise parse_svn_error(res.stderr, "check status", self.workspace_dir)
         return not bool(res.stdout.strip())
 
+    def get_status_summary(self) -> List[str]:
+        """Return lines of uncommitted changes from 'svn status -q'."""
+        res = self.run_cmd(["status", "-q"], check=False)
+        if res.returncode != 0:
+            raise parse_svn_error(res.stderr, "check status", self.workspace_dir)
+        return [line.rstrip() for line in res.stdout.splitlines() if line.strip()]
+
     def get_versioned_files(self) -> List[Path]:
         """
         Return list of all versioned file paths in the SVN workspace (relative to workspace_dir).
@@ -143,9 +218,7 @@ class SvnWorkspace:
         if res.returncode != 0:
             if "is already under version control" not in res.stderr and "already exists" not in res.stderr:
                 logger.error("Failed to 'svn add %s': %s", posix_path, res.stderr.strip())
-                raise subprocess.CalledProcessError(
-                    res.returncode, [self.svn_bin, "add", posix_path], res.stdout, res.stderr
-                )
+                raise parse_svn_error(res.stderr, f"add '{posix_path}'", self.workspace_dir)
 
     def stage_rm(self, rel_path: Path) -> None:
         """Run svn rm <filepath>."""
@@ -156,9 +229,7 @@ class SvnWorkspace:
                 logger.warning("File %s not under SVN control to remove.", posix_path)
             else:
                 logger.error("Failed to 'svn rm %s': %s", posix_path, res.stderr.strip())
-                raise subprocess.CalledProcessError(
-                    res.returncode, [self.svn_bin, "rm", posix_path], res.stdout, res.stderr
-                )
+                raise parse_svn_error(res.stderr, f"remove '{posix_path}'", self.workspace_dir)
 
     def commit(self, message: str) -> None:
         """Run svn commit using a temporary file with -F to support arbitrary message lengths and encodings."""
@@ -175,9 +246,7 @@ class SvnWorkspace:
             res = self.run_cmd(["commit", "-F", str(tf_path)], check=False)
             if res.returncode != 0:
                 logger.error("Failed to 'svn commit': %s", res.stderr.strip())
-                raise subprocess.CalledProcessError(
-                    res.returncode, [self.svn_bin, "commit", "-F", str(tf_path)], res.stdout, res.stderr
-                )
+                raise parse_svn_error(res.stderr, "commit", self.workspace_dir)
             if res.stdout:
                 logger.info("SVN commit output:\n%s", res.stdout.strip())
         finally:
@@ -220,6 +289,6 @@ class SvnWorkspace:
         res = self.run_cmd(["update"], check=False)
         if res.returncode != 0:
             logger.error("Failed to 'svn update': %s", res.stderr.strip())
-            raise subprocess.CalledProcessError(res.returncode, [self.svn_bin, "update"], res.stdout, res.stderr)
+            raise parse_svn_error(res.stderr, "update", self.workspace_dir)
         if res.stdout:
             logger.info("SVN update output:\n%s", res.stdout.strip())

{git2svn-0.4.1 → git2svn-0.5.1/git2svn.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git2svn
-Version: 0.4.1
+Version: 0.5.1
 Summary: CLI utility to synchronize changes from a local Git repository to a local SVN working copy
 Author: Simon
 License: Apache-2.0
@@ -35,7 +35,7 @@ Dynamic: license-file
 <p align="center">
   <a href="https://github.com/simon123h/git2svn/actions/workflows/ci.yml"><img src="https://github.com/simon123h/git2svn/actions/workflows/ci.yml/badge.svg?branch=main" alt="Build Status"></a>
   <a href="https://codecov.io/gh/simon123h/git2svn"><img src="https://codecov.io/gh/simon123h/git2svn/branch/main/graph/badge.svg" alt="Coverage"></a>
-  <a href="https://pypi.org/project/git2svn/"><img src="https://img.shields.io/pypi/v/git2svn?color=blue" alt="PyPI Version"></a>
+  <a href="https://pypi.org/project/git2svn/"><img src="https://img.shields.io/pypi/v/git2svn?color=green" alt="PyPI Version"></a>
   <img src="https://img.shields.io/badge/Python-v3.11+-3776AB?logo=python&logoColor=white" alt="Python Version">
   <img src="https://img.shields.io/endpoint?url=https%3A%2F%2Ftokei.kojix2.net%2Fbadge%2Fgithub%2Fsimon123h%2Fgit2svn%2Flines" alt="Lines of Code">
   <a href="https://github.com/simon123h/git2svn/releases"><img src="https://badgen.net/github/release/simon123h/git2svn?color=orange" alt="Latest Release"></a>

{git2svn-0.4.1 → git2svn-0.5.1}/tests/test_e2e.py

@@ -232,3 +232,151 @@ class TestGit2SvnE2E(unittest.TestCase):
         status = self._svn_status()
         self.assertIn("D       obsolete.txt", status)
         self.assertIn("A       brand_new.txt", status)
+
+    def test_e2e_replay_conflict_pause_and_continue(self):
+        """Test replay pausing on a patch conflict in a real SVN WC and resuming with --continue."""
+        # 1. Base commit in Git and SVN
+        f_git = self.git_dir / "conflict_target.txt"
+        f_git.write_text("line 1\nline 2\nline 3\n", encoding="utf-8")
+        base_hash = self._git_commit("base: conflict target")
+
+        (self.svn_wc_dir / "conflict_target.txt").write_text("line 1\nline 2\nline 3\n", encoding="utf-8")
+        subprocess.run([SVN_BIN, "add", "conflict_target.txt"], cwd=self.svn_wc_dir, check=True)
+        subprocess.run([SVN_BIN, "commit", "-m", "init conflict target"], cwd=self.svn_wc_dir, check=True)
+
+        # 2. Modify in SVN out-of-band to cause conflict
+        (self.svn_wc_dir / "conflict_target.txt").write_text("line 1 DIFFERENT\nline 2\nline 3\n", encoding="utf-8")
+        subprocess.run([SVN_BIN, "commit", "-m", "remote edit in svn"], cwd=self.svn_wc_dir, check=True)
+        subprocess.run([SVN_BIN, "update"], cwd=self.svn_wc_dir, check=True)
+
+        # 3. Git commit 1 (touches line 1 and 2, which conflicts)
+        f_git.write_text("line 1 GIT_EDIT\nline 2 GIT_EDIT\nline 3\n", encoding="utf-8")
+        self._git_commit("feat: conflicting git commit")
+
+        # 4. Git commit 2 (subsequent non-conflicting commit)
+        f_next = self.git_dir / "subsequent.txt"
+        f_next.write_text("subsequent content\n", encoding="utf-8")
+        c2_hash = self._git_commit("feat: subsequent commit")
+
+        # 5. Run replay range - should pause with non-zero exit code due to conflict
+        exit_code = cli_main(["replay", f"{base_hash}..{c2_hash}", "-g", str(self.git_dir), "-s", str(self.svn_wc_dir)])
+        self.assertNotEqual(exit_code, 0)
+
+        # Verify .rej artifact exists
+        rej_file = self.svn_wc_dir / "conflict_target.txt.rej"
+        self.assertTrue(rej_file.exists())
+
+        # 6. Resolve conflict manually in SVN working copy and remove .rej artifact
+        (self.svn_wc_dir / "conflict_target.txt").write_text(
+            "line 1 RESOLVED\nline 2 GIT_EDIT\nline 3\n", encoding="utf-8"
+        )
+        rej_file.unlink()
+
+        # 7. Continue replay
+        cont_code = cli_main(["replay", "--continue", "-g", str(self.git_dir), "-s", str(self.svn_wc_dir)])
+        self.assertEqual(cont_code, 0)
+
+        # Verify SVN working copy is clean and both commits are in SVN log
+        self.assertEqual(self._svn_status().strip(), "")
+        _, full_log = self._svn_log_messages()
+        self.assertIn("conflicting git commit", full_log)
+        self.assertIn("subsequent commit", full_log)
+
+        # Verify final files on disk in SVN
+        self.assertEqual(
+            (self.svn_wc_dir / "conflict_target.txt").read_text(encoding="utf-8"),
+            "line 1 RESOLVED\nline 2 GIT_EDIT\nline 3\n",
+        )
+        self.assertEqual((self.svn_wc_dir / "subsequent.txt").read_text(encoding="utf-8"), "subsequent content\n")
+
+    def test_e2e_file_renames_and_moves(self):
+        """Test replay correctly handles file renames and moves across directories in real SVN."""
+        # 1. Base commit: create src/old_name.txt
+        src_dir = self.git_dir / "src"
+        src_dir.mkdir()
+        orig_file = src_dir / "old_name.txt"
+        orig_file.write_text("print('hello rename')\n", encoding="utf-8")
+        base_hash = self._git_commit("init: original file")
+
+        # Replay base to SVN
+        code_base = cli_main(["replay", base_hash, "-g", str(self.git_dir), "-s", str(self.svn_wc_dir)])
+        self.assertEqual(code_base, 0)
+
+        # 2. Git commit: rename src/old_name.txt -> src/nested/renamed.txt
+        nested_dir = src_dir / "nested"
+        nested_dir.mkdir()
+        subprocess.run([GIT_BIN, "mv", "src/old_name.txt", "src/nested/renamed.txt"], cwd=self.git_dir, check=True)
+        rename_hash = self._git_commit("refactor: move and rename file")
+
+        # 3. Replay rename commit to SVN
+        code_rename = cli_main(
+            ["replay", f"{base_hash}..{rename_hash}", "-g", str(self.git_dir), "-s", str(self.svn_wc_dir)]
+        )
+        self.assertEqual(code_rename, 0)
+
+        # 4. Verify SVN state
+        self.assertFalse((self.svn_wc_dir / "src" / "old_name.txt").exists())
+        renamed_svn = self.svn_wc_dir / "src" / "nested" / "renamed.txt"
+        self.assertTrue(renamed_svn.is_file())
+        self.assertEqual(renamed_svn.read_text(encoding="utf-8"), "print('hello rename')\n")
+        self.assertEqual(self._svn_status().strip(), "")
+
+    def test_e2e_binary_files(self):
+        """Test replay correctly handles adding and modifying binary files with null bytes in real SVN."""
+        # 1. Root commit
+        (self.git_dir / "init.txt").write_text("init\n")
+        root_hash = self._git_commit("init: root commit")
+
+        # Replay root commit to SVN
+        code_root = cli_main(["replay", root_hash, "-g", str(self.git_dir), "-s", str(self.svn_wc_dir)])
+        self.assertEqual(code_root, 0)
+
+        # 2. Add binary file
+        bin_git = self.git_dir / "image.bin"
+        initial_bytes = bytes([0x00, 0xFF, 0xFE, 0x01, 0x00, 0x42, 0xAA, 0x55] * 32)
+        bin_git.write_bytes(initial_bytes)
+        self._git_commit("feat: add binary image")
+
+        # 3. Modify binary file
+        modified_bytes = bytes([0x00, 0x00, 0xFF, 0xEE, 0xDD, 0xCC, 0xBB, 0xAA] * 40)
+        bin_git.write_bytes(modified_bytes)
+        mod_hash = self._git_commit("fix: update binary bytes")
+
+        # 4. Replay range to SVN
+        code = cli_main(["replay", f"{root_hash}..{mod_hash}", "-g", str(self.git_dir), "-s", str(self.svn_wc_dir)])
+        self.assertEqual(code, 0)
+
+        # 4. Verify SVN file content is bit-for-bit identical
+        bin_svn = self.svn_wc_dir / "image.bin"
+        self.assertTrue(bin_svn.is_file())
+        self.assertEqual(bin_svn.read_bytes(), modified_bytes)
+        self.assertEqual(self._svn_status().strip(), "")
+
+    def test_e2e_status_real_repo(self):
+        """Test git2svn status command execution against real Git and real SVN repositories."""
+        # Setup base commit in Git and SVN
+        f = self.git_dir / "status_test.txt"
+        f.write_text("status test\n", encoding="utf-8")
+        base_hash = self._git_commit("init: status test file")
+
+        cli_main(["replay", base_hash, "-g", str(self.git_dir), "-s", str(self.svn_wc_dir)])
+
+        # Setup pending commit in Git
+        f.write_text("status test modified\n", encoding="utf-8")
+        pending_hash = self._git_commit("feat: pending feature for status")
+
+        # Configure defaultRange and svnDir in Git config
+        subprocess.run(
+            [GIT_BIN, "config", "git2svn.defaultRange", f"{base_hash}..{pending_hash}"],
+            cwd=self.git_dir,
+            check=True,
+        )
+        subprocess.run(
+            [GIT_BIN, "config", "git2svn.svnDir", str(self.svn_wc_dir)],
+            cwd=self.git_dir,
+            check=True,
+        )
+
+        # Run git2svn status
+        exit_code = cli_main(["status", "-g", str(self.git_dir)])
+        self.assertEqual(exit_code, 0)

{git2svn-0.4.1 → git2svn-0.5.1}/tests/test_git2svn.py

@@ -667,6 +667,34 @@ class TestSynchronizer(unittest.TestCase):
         self.assertTrue((self.svn_path / "trunk_feat.txt").is_file())
         self.assertEqual((self.svn_path / "trunk_feat.txt").read_text(), "trunk feat\n")
 
+    @patch.object(git2svn.SvnWorkspace, "run_cmd")
+    def test_replay_progress_output(self, mock_svn_cmd):
+        """Verify git2svn replay outputs formatted progress indicators with commit title and OK status."""
+        import io
+
+        mock_svn_cmd.return_value = subprocess.CompletedProcess([], 0, stdout="", stderr="")
+
+        base_file = self.git_path / "prog_base.txt"
+        base_file.write_text("prog base\n")
+        subprocess.run(["git", "add", "."], cwd=self.git_path, check=True)
+        subprocess.run(["git", "commit", "-m", "prog base"], cwd=self.git_path, check=True)
+        base_hash = subprocess.run(
+            ["git", "rev-parse", "HEAD"], cwd=self.git_path, capture_output=True, text=True
+        ).stdout.strip()
+
+        commit_file = self.git_path / "prog_feat.txt"
+        commit_file.write_text("prog feat\n")
+        subprocess.run(["git", "add", "."], cwd=self.git_path, check=True)
+        subprocess.run(["git", "commit", "-m", "feat: progress indicator"], cwd=self.git_path, check=True)
+        feat_hash = subprocess.run(
+            ["git", "rev-parse", "HEAD"], cwd=self.git_path, capture_output=True, text=True
+        ).stdout.strip()
+
+        with patch("sys.stdout", new_callable=io.StringIO) as mock_stdout:
+            self.sync_mgr.replay(base_hash, feat_hash)
+            output = mock_stdout.getvalue()
+            self.assertIn(f"[1/1] Applying {feat_hash[:8]}: feat: progress indicator... OK", output)
+
     @patch.object(git2svn.SvnWorkspace, "run_cmd")
     def test_stage_with_git_config_default_range(self, mock_svn_cmd):
         """Verify git2svn stage with no ref arguments falls back to git2svn.defaultRange."""
@@ -954,6 +982,7 @@ class TestEolUtilities(unittest.TestCase):
         self.assertEqual(git_repo.get_config("pull.ff"), "only")
         self.assertIn("git2svn replay", git_repo.get_config("alias.svn-push"))
         self.assertIn("git fetch svn-mirror", git_repo.get_config("alias.svn-pull"))
+        self.assertEqual(git_repo.get_config("alias.svn-status"), "!git2svn status")
 
     def test_setup_interactive_input(self):
         """Verify git2svn setup prompts for svn path via input() when tty."""
@@ -1040,5 +1069,199 @@ class TestEolUtilities(unittest.TestCase):
             self.assertEqual(git2svn.svn.find_svn_binary(), "svn")
 
 
+class TestSvnLockAndCollisionHandling(unittest.TestCase):
+    def setUp(self):
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.path = Path(self.temp_dir.name).resolve()
+        self.workspace = git2svn.SvnWorkspace(self.path)
+
+    def tearDown(self):
+        self.temp_dir.cleanup()
+
+    def test_parse_svn_error_lock(self):
+        stderr = "svn: E155004: Working copy '/tmp/svn_wc' locked.\nsvn: run 'svn cleanup' to remove locks"
+        err = git2svn.svn.parse_svn_error(stderr, "commit", self.path)
+        self.assertIsInstance(err, git2svn.SvnLockError)
+        self.assertIn("is locked", str(err))
+        self.assertIn("svn cleanup", str(err))
+
+    def test_parse_svn_error_out_of_date(self):
+        stderr = "svn: E155015: Aborting commit: 'file.txt' remains in conflict / item is out of date"
+        err = git2svn.svn.parse_svn_error(stderr, "commit", self.path)
+        self.assertIsInstance(err, git2svn.SvnOutOfDateError)
+        self.assertIn("out of date", str(err))
+        self.assertIn("svn update", str(err))
+
+    def test_parse_svn_error_e160024_conflict(self):
+        stderr = "svn: E160024: resource out of date; try updating"
+        err = git2svn.svn.parse_svn_error(stderr, "commit", self.path)
+        self.assertIsInstance(err, git2svn.SvnOutOfDateError)
+        self.assertIn("svn update", str(err))
+
+    @patch.object(git2svn.SvnWorkspace, "run_cmd")
+    def test_commit_raises_lock_error_with_hints(self, mock_cmd):
+        mock_cmd.return_value = subprocess.CompletedProcess(
+            [], 1, stdout="", stderr="svn: E155004: Working copy locked; please run 'svn cleanup'"
+        )
+        with self.assertRaises(git2svn.SvnLockError) as cm:
+            self.workspace.commit("test msg")
+        self.assertIn("svn cleanup", str(cm.exception))
+
+    @patch.object(git2svn.SvnWorkspace, "run_cmd")
+    def test_commit_raises_out_of_date_error_with_hints(self, mock_cmd):
+        mock_cmd.return_value = subprocess.CompletedProcess(
+            [], 1, stdout="", stderr="svn: E155015: Commit failed because item is out of date"
+        )
+        with self.assertRaises(git2svn.SvnOutOfDateError) as cm:
+            self.workspace.commit("test msg")
+        self.assertIn("svn update", str(cm.exception))
+
+    @patch.object(git2svn.SvnWorkspace, "run_cmd")
+    def test_update_raises_lock_error(self, mock_cmd):
+        mock_cmd.return_value = subprocess.CompletedProcess(
+            [], 1, stdout="", stderr="svn: E155004: Working copy locked."
+        )
+        with self.assertRaises(git2svn.SvnLockError):
+            self.workspace.update()
+
+    @patch.object(git2svn.SvnWorkspace, "run_cmd")
+    def test_is_clean_raises_on_lock(self, mock_cmd):
+        mock_cmd.return_value = subprocess.CompletedProcess(
+            [], 1, stdout="", stderr="svn: E155004: Working copy locked."
+        )
+        with self.assertRaises(git2svn.SvnLockError):
+            self.workspace.is_clean()
+
+
+class TestStatus(unittest.TestCase):
+    def setUp(self):
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.path = Path(self.temp_dir.name).resolve()
+        self.git_path = self.path / "git_repo"
+        self.svn_path = self.path / "svn_repo"
+        self.git_path.mkdir()
+        self.svn_path.mkdir()
+        (self.svn_path / ".svn").mkdir()
+
+        subprocess.run(["git", "init"], cwd=self.git_path, check=True, capture_output=True)
+        subprocess.run(["git", "config", "user.name", "Test User"], cwd=self.git_path, check=True)
+        subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=self.git_path, check=True)
+
+        self.git_repo = git2svn.GitRepo(self.git_path)
+        self.svn_workspace = git2svn.SvnWorkspace(self.svn_path)
+        self.patcher = git2svn.Patcher(self.svn_path)
+        self.sync_mgr = git2svn.Synchronizer(self.git_repo, self.svn_workspace, self.patcher)
+
+    def tearDown(self):
+        self.temp_dir.cleanup()
+
+    def test_status_clean_no_commits(self):
+        """Status succeeds when both repos are clean and range has no pending commits."""
+        f = self.git_path / "init.txt"
+        f.write_text("hello\n")
+        subprocess.run(["git", "add", "."], cwd=self.git_path, check=True)
+        subprocess.run(["git", "commit", "-m", "init commit"], cwd=self.git_path, check=True)
+        head = self.git_repo.get_head_commit()
+
+        self.git_repo.set_config("git2svn.defaultRange", f"{head}..{head}")
+
+        with (
+            patch.object(self.svn_workspace, "is_clean", return_value=True),
+            patch.object(self.svn_workspace, "get_info", return_value={"URL": "file:///svn/trunk", "Revision": "10"}),
+        ):
+            code = self.sync_mgr.status()
+            self.assertEqual(code, 0)
+
+    def test_status_pending_commits(self):
+        """Status succeeds and reports pending commits."""
+        f = self.git_path / "base.txt"
+        f.write_text("base\n")
+        subprocess.run(["git", "add", "."], cwd=self.git_path, check=True)
+        subprocess.run(["git", "commit", "-m", "base"], cwd=self.git_path, check=True)
+        base = self.git_repo.get_head_commit()
+
+        f2 = self.git_path / "feat.txt"
+        f2.write_text("feat\n")
+        subprocess.run(["git", "add", "."], cwd=self.git_path, check=True)
+        subprocess.run(["git", "commit", "-m", "feat: new feature"], cwd=self.git_path, check=True)
+        head = self.git_repo.get_head_commit()
+
+        self.git_repo.set_config("git2svn.defaultRange", f"{base}..{head}")
+
+        with (
+            patch.object(self.svn_workspace, "is_clean", return_value=True),
+            patch.object(self.svn_workspace, "get_info", return_value={"URL": "file:///svn/trunk", "Revision": "10"}),
+        ):
+            code = self.sync_mgr.status()
+            self.assertEqual(code, 0)
+
+    def test_status_detects_merge_commits_as_error(self):
+        """Status exits with code 1 if merge commits exist in the range."""
+        f = self.git_path / "base.txt"
+        f.write_text("base\n")
+        subprocess.run(["git", "add", "."], cwd=self.git_path, check=True)
+        subprocess.run(["git", "commit", "-m", "base"], cwd=self.git_path, check=True)
+        base = self.git_repo.get_head_commit()
+
+        init_branch = self.git_repo.get_current_branch()
+        subprocess.run(["git", "checkout", "-b", "side"], cwd=self.git_path, check=True, capture_output=True)
+        f_side = self.git_path / "side.txt"
+        f_side.write_text("side\n")
+        subprocess.run(["git", "add", "."], cwd=self.git_path, check=True)
+        subprocess.run(["git", "commit", "-m", "side commit"], cwd=self.git_path, check=True)
+
+        subprocess.run(["git", "checkout", init_branch], cwd=self.git_path, check=True, capture_output=True)
+        f_main = self.git_path / "main.txt"
+        f_main.write_text("main\n")
+        subprocess.run(["git", "add", "."], cwd=self.git_path, check=True)
+        subprocess.run(["git", "commit", "-m", "main commit"], cwd=self.git_path, check=True)
+
+        # Create merge commit
+        subprocess.run(["git", "merge", "--no-ff", "side", "-m", "merge side"], cwd=self.git_path, check=True)
+        head = self.git_repo.get_head_commit()
+
+        self.git_repo.set_config("git2svn.defaultRange", f"{base}..{head}")
+
+        with (
+            patch.object(self.svn_workspace, "is_clean", return_value=True),
+            patch.object(self.svn_workspace, "get_info", return_value={"URL": "file:///svn/trunk", "Revision": "10"}),
+        ):
+            code = self.sync_mgr.status()
+            self.assertEqual(code, 1)
+
+    def test_status_detects_paused_replay_state(self):
+        """Status exits with code 1 when an in-progress replay is paused."""
+        git2svn.save_replay_state(
+            self.svn_path,
+            {
+                "state": "CONFLICT_PAUSED",
+                "current_commit": "12345678",
+                "current_commit_msg": "conflict commit",
+                "remaining_commits": ["abcdef12"],
+                "completed_commits": 1,
+                "total_commits": 3,
+            },
+        )
+        try:
+            with (
+                patch.object(self.svn_workspace, "is_clean", return_value=True),
+                patch.object(
+                    self.svn_workspace, "get_info", return_value={"URL": "file:///svn/trunk", "Revision": "10"}
+                ),
+            ):
+                code = self.sync_mgr.status()
+                self.assertEqual(code, 1)
+        finally:
+            git2svn.clear_replay_state(self.svn_path)
+
+    def test_status_cli_dispatch(self):
+        """Verify git2svn status CLI command executes correctly."""
+        self.git_repo.set_config("git2svn.svnDir", str(self.svn_path))
+        with patch.object(git2svn.Synchronizer, "status", return_value=0) as mock_status:
+            code = git2svn.main(["--git-dir", str(self.git_path), "status"])
+            self.assertEqual(code, 0)
+            mock_status.assert_called_once()
+
+
 if __name__ == "__main__":
     unittest.main()