git2svn 0.6.0__tar.gz → 0.7.0__tar.gz

{git2svn-0.6.0/git2svn.egg-info → git2svn-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git2svn
-Version: 0.6.0
+Version: 0.7.0
 Summary: CLI utility to synchronize changes from a local Git repository to a local SVN working copy
 Author: Simon
 License: Apache-2.0

{git2svn-0.6.0 → git2svn-0.7.0}/docs/arc42/README.md

@@ -79,6 +79,9 @@ classDiagram
         +main()
         +build_parser()
     }
+    class Setup {
+        +run_setup()
+    }
     class Synchronizer {
         +stage()
         +stage_snapshot()
@@ -86,6 +89,10 @@ classDiagram
         +replay_continue()
         +replay_abort()
         +replay_skip()
+        +status()
+    }
+    class StatusReporter {
+        +report()
     }
     class GitRepo {
         +get_diff()
@@ -103,6 +110,12 @@ classDiagram
     class Patcher {
         +apply_diff()
     }
+    class TerminalColor {
+        +bold_cyan()
+        +bold_green()
+        +bold_yellow()
+        +bold_red()
+    }
     class EOL {
         +detect_file_eol()
         +normalize_file_eol()
@@ -116,19 +129,28 @@ classDiagram
     }
 
     CLI --> Synchronizer
+    CLI --> Setup
+    Synchronizer --> StatusReporter
     Synchronizer --> GitRepo
     Synchronizer --> SvnWorkspace
     Synchronizer --> Patcher
     Synchronizer --> EOL
     Synchronizer --> State
+    StatusReporter --> TerminalColor
+    StatusReporter --> GitRepo
+    StatusReporter --> SvnWorkspace
+    StatusReporter --> State
 ```
 
 ### 5.2 Level 2: Component Responsibilities
 
 | Component | File | Responsibility |
 | :--- | :--- | :--- |
-| **CLI Controller** | `git2svn/cli.py` | Argument parsing, help output, pre-flight target banner, command dispatch, and exit codes. |
+| **CLI Controller** | `git2svn/cli.py` | Argument parsing, help output, command dispatch, and exit code handling. |
+| **Setup Service** | `git2svn/setup.py` | Automated tracking branch detection, config discovery, and Git productivity alias registration. |
 | **Synchronizer Service** | `git2svn/core.py` | Orchestrates diff application, object extraction, EOL normalization, replay loop, and conflict lifecycle. |
+| **Status Reporter** | `git2svn/status.py` | Diagnostic inspection of Git, SVN working copy, conflict state, and pending commit queues. |
+| **Color Terminal** | `git2svn/colors.py` | ANSI styling, auto/always/never detection, and `NO_COLOR` standard compliance. |
 | **Git Adapter** | `git2svn/git.py` | Encapsulates `git` subprocess executions, ref parsing, name-status parsing, and object extraction. |
 | **SVN Adapter** | `git2svn/svn.py` | Encapsulates `svn` subprocess executions (`add`, `rm`, `commit`, `revert`, `info`, `status`). |
 | **Patcher** | `git2svn/patcher.py` | Encapsulates `git apply` with whitespace tolerance and reject file creation. |
@@ -226,4 +248,4 @@ Detailed architectural concepts are documented in **[Cross-Cutting Concepts](con
 
 ## 9. Architecture Decisions (ADRs)
 
-Architecture Decision Records (ADR-1 through ADR-10) are documented in **[Architecture Decision Records](adrs.md)**.
+Architecture Decision Records (ADR-1 through ADR-12) are documented in **[Architecture Decision Records](adrs.md)**.

{git2svn-0.6.0 → git2svn-0.7.0}/docs/arc42/adrs.md

@@ -85,3 +85,18 @@ This document contains the Architecture Decision Records (ADRs) for `git2svn`.
   - 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.
 
+---
+
+### ADR-12: Scope Boundary: Adapter Bridge vs. Autonomous Master-Slave Exporter
+* **Context:** In scenarios where Git is the sole upstream source of truth without an automated reverse `svn2git` mirror creating tracking branches (e.g. `origin/svn-mirror/trunk`), `git2svn` has no external reference point to determine which Git commit corresponds to the current state of the SVN working copy. To operate autonomously without an explicit Git range or external mirror, `git2svn` would need to record and track synchronization state across boundaries (e.g. via SVN commit trailers, custom root revision properties, or local/remote sync tags), implement out-of-band conflict reconciliation logic, and handle multi-branch topology mapping.
+* **Decision:** Explicitly maintain `git2svn`'s scope as a lightweight, stateless **adapter bridge** rather than an autonomous master-slave repository replication system:
+  1. `git2svn` will not take on the responsibility of an internal state machine or persistent cross-VCS metadata synchronization engine.
+  2. In the standard workflow, state and collision detection remain externalized in Git (via mirror tracking branches) and SVN working copy revisions.
+  3. When operating without an SVN-to-Git mirror, `git2svn` continues to function reliably as an explicit delivery tool via user-directed arguments:
+     - `git2svn replay <base-commit>..<target-commit>` (explicitly providing the base commit where SVN last left off).
+     - `git2svn stage --snapshot <target-ref>` (statelessly projecting the desired Git tree onto the SVN workspace without requiring historical ancestry).
+* **Consequences:**
+  - Preserves Unix philosophy: `git2svn` focuses solely on reliably applying Git diffs and tree states to an SVN working copy.
+  - Keeps the codebase lean, robust, and free of fragile metadata synchronization or repository reconciliation logic.
+  - Avoids architectural divergence and false promises regarding bidirectional synchronization or unmanaged out-of-band SVN mutations.
+

{git2svn-0.6.0 → git2svn-0.7.0}/git2svn/__init__.py

@@ -6,11 +6,12 @@ to a local Subversion (SVN) working copy.
 from __future__ import annotations
 
 from .cli import build_parser, main, parse_cli_args
-from .colors import TerminalColor
+from .colors import ColoredLogFormatter, TerminalColor
 from .core import Synchronizer
 from .eol import detect_file_eol, normalize_file_eol
 from .git import FileChange, GitRepo, parse_name_status, parse_name_status_z, parse_ref_arguments
 from .patcher import Patcher
+from .setup import run_setup
 from .state import (
     clean_conflict_artifacts,
     clear_replay_state,
@@ -18,6 +19,7 @@ from .state import (
     load_replay_state,
     save_replay_state,
 )
+from .status import StatusReporter
 from .svn import SvnError, SvnLockError, SvnOutOfDateError, SvnWorkspace
 
 try:
@@ -45,6 +47,9 @@ __all__ = [
     "SvnOutOfDateError",
     "Patcher",
     "TerminalColor",
+    "ColoredLogFormatter",
+    "StatusReporter",
+    "run_setup",
     "FileChange",
     "parse_ref_arguments",
     "parse_name_status",

{git2svn-0.6.0 → git2svn-0.7.0}/git2svn/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.6.0'
-__version_tuple__ = version_tuple = (0, 6, 0)
+__version__ = version = '0.7.0'
+__version_tuple__ = version_tuple = (0, 7, 0)
 
 __commit_id__ = commit_id = None

{git2svn-0.6.0 → git2svn-0.7.0}/git2svn/cli.py

@@ -8,6 +8,7 @@ import sys
 from pathlib import Path
 from typing import List, Optional
 
+from .colors import ColoredLogFormatter, TerminalColor
 from .core import Synchronizer
 from .git import GitRepo
 from .patcher import Patcher
@@ -229,126 +230,9 @@ def build_parser() -> argparse.ArgumentParser:
 
 def handle_setup(git_repo: GitRepo, svn_dir_path: Optional[Path | str]) -> int:
     """Automate repository configuration, branch detection, and productivity aliases."""
-    if not git_repo.is_valid_repo():
-        print(f"Error: '{git_repo.repo_dir}' is not a valid Git repository.", file=sys.stderr)
-        return 1
-
-    # 1. Resolve SVN working copy path
-    resolved_svn: Optional[Path] = None
-    if svn_dir_path:
-        resolved_svn = Path(svn_dir_path).resolve()
-    else:
-        # Check existing config or environment variable
-        cfg_svn = git_repo.get_config("git2svn.svnDir")
-        if cfg_svn:
-            resolved_svn = Path(cfg_svn).resolve()
-        elif "SVN_DIR" in os.environ:
-            resolved_svn = Path(os.environ["SVN_DIR"]).resolve()
-
-    if not resolved_svn:
-        # Interactive prompt if stdin is a tty, otherwise display error
-        if sys.stdin.isatty():
-            try:
-                entered = input("Path to SVN working copy: ").strip()
-                if entered:
-                    resolved_svn = Path(entered).resolve()
-            except (EOFError, KeyboardInterrupt):
-                print("", file=sys.stderr)
-                return 1
-
-    if not resolved_svn:
-        print(
-            "Error: SVN working copy path must be provided: 'git2svn setup <path/to/svn>'.",
-            file=sys.stderr,
-        )
-        return 1
+    from .setup import run_setup
 
-    if not (resolved_svn / ".svn").exists():
-        print(
-            f"Error: '{resolved_svn}' does not appear to be an SVN working copy (no .svn found).",
-            file=sys.stderr,
-        )
-        return 1
-
-    # 2. Auto-detect local trunk branch
-    local_branches = git_repo.get_local_branches()
-    detected_trunk: Optional[str] = None
-    if "trunk" in local_branches:
-        detected_trunk = "trunk"
-    elif "main" in local_branches:
-        detected_trunk = "main"
-    elif "master" in local_branches:
-        detected_trunk = "master"
-    else:
-        # Use current branch if available
-        current = git_repo.get_current_branch()
-        if current and current in local_branches:
-            detected_trunk = current
-        elif local_branches:
-            detected_trunk = local_branches[0]
-
-    # 3. Auto-detect remote tracking mirror branch
-    remote_branches = git_repo.get_remote_branches()
-    detected_mirror: Optional[str] = None
-    preferred_remotes = ["svn-mirror/trunk", "origin/trunk", "svn/trunk", "mirror/trunk"]
-    for pref in preferred_remotes:
-        if pref in remote_branches:
-            detected_mirror = pref
-            break
-
-    if not detected_mirror and detected_trunk:
-        # Check for remote branch matching <remote>/<detected_trunk>
-        candidates = [b for b in remote_branches if b.endswith(f"/{detected_trunk}")]
-        if candidates:
-            # Prefer svn-mirror if present
-            svn_cand = [c for c in candidates if "svn" in c.lower() or "mirror" in c.lower()]
-            detected_mirror = svn_cand[0] if svn_cand else candidates[0]
-
-    # 4. Apply Git configuration
-    # SVN directory path (use forward slashes for cross-platform consistency in git config)
-    svn_dir_str = str(resolved_svn).replace("\\", "/")
-    git_repo.set_config("git2svn.svnDir", svn_dir_str)
-    git_repo.set_config("pull.ff", "only")
-
-    default_range: Optional[str] = None
-    if detected_mirror and detected_trunk:
-        default_range = f"{detected_mirror}..{detected_trunk}"
-        git_repo.set_config("git2svn.defaultRange", default_range)
-
-    # 5. Configure productivity aliases
-    mirror_remote = detected_mirror.split("/")[0] if detected_mirror else "svn-mirror"
-    mirror_branch = detected_mirror or f"{mirror_remote}/trunk"
-    trunk_name = detected_trunk or "trunk"
-
-    push_script = (
-        f"!f() {{ git2svn replay && git fetch {mirror_remote} && git checkout {trunk_name} && "
-        f"if git diff --quiet {trunk_name} {mirror_branch}; then "
-        f"git reset --hard {mirror_branch}; "
-        f"else echo '[git svn-push] Warning: {trunk_name} differs from {mirror_branch}. Not resetting.' >&2; fi; }}; f"
-    )
-    pull_script = (
-        f"!f() {{ git fetch {mirror_remote} && git checkout {trunk_name} && "
-        f"if ! git merge --ff-only {mirror_branch} 2>/dev/null; then "
-        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}")
-    if default_range:
-        print(f"  git2svn.defaultRange= {default_range}")
-    else:
-        print("  git2svn.defaultRange= (not set; could not detect mirror branch)")
-    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
+    return run_setup(git_repo, svn_dir_path)
 
 
 def parse_cli_args(argv: Optional[List[str]] = None) -> argparse.Namespace:
@@ -374,9 +258,6 @@ def parse_cli_args(argv: Optional[List[str]] = None) -> argparse.Namespace:
 def main(argv: Optional[List[str]] = None) -> int:
     args = parse_cli_args(argv)
 
-    log_level = logging.DEBUG if args.verbose else logging.INFO
-    logging.basicConfig(level=log_level, format="[%(levelname)s] %(message)s")
-
     git_dir = args.git_dir
     if not git_dir and args.command == "replay" and getattr(args, "replay_action", None):
         cwd = Path.cwd()
@@ -386,6 +267,20 @@ def main(argv: Optional[List[str]] = None) -> int:
 
     git_dir = git_dir or find_default_git_dir()
     git_repo = GitRepo(git_dir)
+
+    # Color mode: CLI --color -> git config git2svn.color -> "auto"
+    color_mode = getattr(args, "color", None)
+    if not color_mode:
+        config_color = git_repo.get_config("git2svn.color") if git_repo.is_valid_repo() else None
+        color_mode = config_color if config_color in ("auto", "always", "never") else "auto"
+
+    log_level = logging.DEBUG if args.verbose else logging.INFO
+    handler = logging.StreamHandler()
+    handler.setFormatter(ColoredLogFormatter(TerminalColor(color_mode)))
+    root_logger = logging.getLogger()
+    root_logger.setLevel(log_level)
+    root_logger.handlers = [handler]
+
     if not git_repo.is_valid_repo():
         print(f"Error: '{git_dir}' is not a valid Git repository.", file=sys.stderr)
         return 1
@@ -441,12 +336,6 @@ def main(argv: Optional[List[str]] = None) -> int:
         print(f"Error: '{svn_dir}' does not appear to be an SVN working copy (no .svn found).", file=sys.stderr)
         return 1
 
-    # Color mode: CLI --color -> git config git2svn.color -> "auto"
-    color_mode = getattr(args, "color", None)
-    if not color_mode:
-        config_color = git_repo.get_config("git2svn.color")
-        color_mode = config_color if config_color in ("auto", "always", "never") else "auto"
-
     patcher = Patcher(svn_dir, dry_run=dry_run)
     sync_mgr = Synchronizer(
         git_repo,
@@ -473,6 +362,11 @@ def main(argv: Optional[List[str]] = None) -> int:
 
     try:
         if args.command == "stage":
+            is_snapshot = getattr(args, "snapshot", False)
+            if not ref1 and is_snapshot:
+                ref1 = "HEAD"
+                logger.info("No ref specified for snapshot stage; defaulting to HEAD.")
+
             if not ref1:
                 print(
                     "Error: stage requires a commit or range (e.g. 'git2svn stage main..feature') "
@@ -484,7 +378,7 @@ def main(argv: Optional[List[str]] = None) -> int:
                 ref1,
                 ref2,
                 use_copy=use_copy,
-                snapshot=getattr(args, "snapshot", False),
+                snapshot=is_snapshot,
             )
         elif args.command == "replay":
             action = getattr(args, "replay_action", None)

{git2svn-0.6.0 → git2svn-0.7.0}/git2svn/colors.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import logging
 import os
 import sys
 
@@ -90,7 +91,7 @@ class TerminalColor:
     def bold_cyan(self, text: str) -> str:
         return self.colorize(text, self.BOLD_CYAN)
 
-    # Semantic badges
+    # Semantic badges & prefixes
     def ok(self, text: str = "OK") -> str:
         return self.bold_green(f"✔ {text}")
 
@@ -102,3 +103,45 @@ class TerminalColor:
 
     def error(self, text: str = "Error") -> str:
         return self.bold_red(f"✖ {text}")
+
+    def info_badge(self, text: str = "[INFO]") -> str:
+        return self.bold_cyan(text)
+
+    def target_badge(self, text: str = "[TARGET]") -> str:
+        return self.bold_cyan(text)
+
+    def warn_badge(self, text: str = "[WARN]") -> str:
+        return self.bold_yellow(text)
+
+    def error_badge(self, text: str = "[ERROR]") -> str:
+        return self.bold_red(text)
+
+    def paused_badge(self, text: str = "[PAUSED]") -> str:
+        return self.bold_yellow(text)
+
+
+class ColoredLogFormatter(logging.Formatter):
+    """Custom logging formatter that colorizes log level prefixes using TerminalColor."""
+
+    def __init__(self, color: TerminalColor):
+        super().__init__()
+        self.color = color
+
+    def format(self, record: logging.LogRecord) -> str:
+        levelname = record.levelname
+        msg = record.getMessage()
+        if not self.color.enabled:
+            return f"[{levelname}] {msg}"
+
+        if levelname == "INFO":
+            badge = self.color.info_badge("[INFO]")
+        elif levelname in ("WARNING", "WARN"):
+            badge = self.color.warn_badge(f"[{levelname}]")
+        elif levelname in ("ERROR", "CRITICAL"):
+            badge = self.color.error_badge(f"[{levelname}]")
+        elif levelname == "DEBUG":
+            badge = self.color.dim(f"[{levelname}]")
+        else:
+            badge = f"[{levelname}]"
+
+        return f"{badge} {msg}"

{git2svn-0.6.0 → git2svn-0.7.0}/git2svn/core.py

@@ -52,9 +52,10 @@ class Synchronizer:
         svn_rev = svn_info.get("Revision")
         svn_suffix = f" (r{svn_rev})" if svn_rev else ""
 
+        target_badge = self.color.target_badge("[TARGET]")
         banner = (
-            f"[TARGET] Git source : {self.git.repo_dir.name} [{branch} @ {head}] -> ref: {target_ref_spec}\n"
-            f"[TARGET] SVN target : {self.svn.workspace_dir.name} [{svn_target}{svn_suffix}]"
+            f"{target_badge} Git source : {self.git.repo_dir.name} [{branch} @ {head}] -> ref: {target_ref_spec}\n"
+            f"{target_badge} SVN target : {self.svn.workspace_dir.name} [{svn_target}{svn_suffix}]"
         )
         print(banner)
 
@@ -71,7 +72,10 @@ class Synchronizer:
         If use_copy=True, brute-force copies files using Git object DB (bypassing patch).
         """
         if snapshot:
-            self.stage_snapshot(ref1)
+            # If a range was supplied (e.g. origin/main..main or ref1 and ref2), snapshot targets the end ref
+            is_single, start_or_commit, end_ref = parse_ref_arguments(ref1, ref2)
+            target_ref = end_ref if not is_single and end_ref else start_or_commit
+            self.stage_snapshot(target_ref)
             return
 
         is_single, start_or_commit, end_ref = parse_ref_arguments(ref1, ref2)
@@ -381,8 +385,9 @@ class Synchronizer:
                     rej_rel = [str(r.relative_to(self.svn.workspace_dir)) for r in rej_files]
                     rej_info = "\nConflicts detected in:\n" + "\n".join(f"  - {f}" for f in rej_rel)
 
+                paused_badge = self.color.paused_badge("[PAUSED]")
                 print(
-                    f'\n[PAUSED] Conflict while applying commit {commit_hash[:8]} ({idx}/{total_commits}): "{first_line}"'
+                    f'\n{paused_badge} Conflict while applying commit {commit_hash[:8]} ({idx}/{total_commits}): "{first_line}"'
                     f"{rej_info}\n\n"
                     f"To resolve:\n"
                     f"  1. Resolve conflicts in '{self.svn.workspace_dir}' and stage changes ('svn add' / 'svn rm').\n"
@@ -524,127 +529,6 @@ class Synchronizer:
             0 if clean and ready / in sync
             1 if errors, working copy locked, merge conflicts, or linear violations exist
         """
-        has_error = False
-        c = self.color
+        from .status import StatusReporter
 
-        # 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(c.bold_red("[Replay In Progress]"))
-            print(
-                f'  State     : {c.bold_red("PAUSED")} (conflict at commit {c.yellow(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 : {c.bold_red(', '.join(rel_rejs))}")
-            action_text = (
-                f"Resolve conflicts and run {c.bold_cyan('git2svn replay --continue')} (or '--abort' / '--skip')"
-            )
-            print(f"  Action    : {action_text}\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'{c.yellow(head_commit)} "{head_subject}"' if head_subject else c.yellow(head_commit)
-
-        print(c.bold_cyan("[Git Workspace]"))
-        print(f"  Repository: {self.git.repo_dir}")
-        print(f"  Branch    : {c.bold(branch)} (at {head_desc})")
-        if git_clean:
-            print(f"  Tree      : {c.bold_green('Clean')}")
-        else:
-            print(f"  Tree      : {c.bold_yellow('Dirty')} (uncommitted changes present)")
-
-        # 3. SVN Working Copy Status
-        print(f"\n{c.bold_cyan('[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" ({c.dim(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(f"  Tree      : {c.bold_green('Clean')} (no uncommitted changes, unlocked)")
-            else:
-                uncommitted = self.svn.get_status_summary()
-                print(f"  Tree      : {c.bold_yellow(f'Dirty ({len(uncommitted)} uncommitted changes)')}")
-                for item in uncommitted[:5]:
-                    print(f"              {item}")
-                if len(uncommitted) > 5:
-                    print(f"              {c.dim(f'... and {len(uncommitted) - 5} more')}")
-        except SvnError as e:
-            has_error = True
-            print(f"  Tree      : {c.bold_red(f'Error: {e.args[0].splitlines()[0]}')}")
-
-        # 4. Synchronization Queue & Default Range
-        default_range = self.git.get_config("git2svn.defaultRange")
-        print(f"\n{c.bold_cyan('[Synchronization]')}")
-        if not default_range:
-            print(
-                f"  Range     : {c.dim('Not configured')} (run 'git2svn setup' or 'git config git2svn.defaultRange <range>')"
-            )
-        else:
-            print(f"  Range     : {c.bold(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: List[str] = []
-                else:
-                    assert end_ref is not None
-                    if not self.git.ref_exists(start_ref):
-                        warn_msg = f"Range start ref '{start_ref}' not found in Git."
-                        print(f"  Warning   : {c.bold_yellow(warn_msg)}")
-                        commits = []
-                        merges = []
-                    elif not self.git.ref_exists(end_ref):
-                        warn_msg = f"Range end ref '{end_ref}' not found in Git."
-                        print(f"  Warning   : {c.bold_yellow(warn_msg)}")
-                        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
-                    inv_msg = f"INVALID ({len(merges)} merge commits found in range - linear rebase required)"
-                    print(f"  Linearity : {c.bold_red(inv_msg)}")
-                else:
-                    print(f"  Linearity : {c.bold_green('OK')} (strictly linear)")
-
-                if not commits:
-                    print(f"  Pending   : {c.bold_green('In sync')} (0 commits to replay)")
-                else:
-                    pending_title = f"{len(commits)} commit(s) ready to replay:"
-                    print(f"  Pending   : {c.bold_yellow(pending_title)}")
-                    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"              {c.dim(f'{idx}.')} [{c.yellow(c_hash[:8])}] {subject}")
-                    if len(commits) > 10:
-                        print(f"              {c.dim(f'... and {len(commits) - 10} more')}")
-            except Exception as e:
-                err_msg = f"Could not parse range '{default_range}': {e}"
-                print(f"  Error     : {c.bold_red(err_msg)}")
-                has_error = True
-
-        if has_error:
-            return 1
-        return 0
+        return StatusReporter(self.git, self.svn, self.color).report()