pygitgo 1.8.2__tar.gz → 1.9.0__tar.gz

{pygitgo-1.8.2 → pygitgo-1.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygitgo
-Version: 1.8.2
+Version: 1.9.0
 Summary: GitGo CLI - Your Fast Git Companion. Simplifies git push, link, stash, and user management.
 Author: Huerte
 License: GPL-3.0-or-later
@@ -76,6 +76,8 @@ gitgo new my-app python
 - [License](#license)
 - [Changelog](CHANGELOG.md)
 - [Contributing Guide](CONTRIBUTING.md)
+- [First Contribution Walkthrough](docs/first-contribution.md)
+- [Troubleshooting](docs/troubleshooting.md)
 
 ---
 
@@ -388,7 +390,7 @@ gitgo config get <key>
 | Key | Description | Default |
 |-----|-------------|---------|
 | `default-branch` | The branch used for push/link | `main` |
-| `default-message` | The commit message used for push | `New Project Update` |
+| `default-message` | The commit message used for push | `chore: new changes applied` |
 
 ### Global Flags
 
@@ -415,6 +417,8 @@ gitgo -r        # verify GitGo is ready
 
 Contributions are welcome. Read [CONTRIBUTING.md](CONTRIBUTING.md) for the full guide, including project structure, test instructions, commit conventions, and a [Good First Issues](CONTRIBUTING.md#good-first-issues) table if you're not sure where to start.
 
+If this is your first time contributing to an open-source project, follow our step-by-step [First Contribution Walkthrough](docs/first-contribution.md) guide.
+
 ---
 
 ## Credits

{pygitgo-1.8.2 → pygitgo-1.9.0}/README.md

@@ -51,6 +51,8 @@ gitgo new my-app python
 - [License](#license)
 - [Changelog](CHANGELOG.md)
 - [Contributing Guide](CONTRIBUTING.md)
+- [First Contribution Walkthrough](docs/first-contribution.md)
+- [Troubleshooting](docs/troubleshooting.md)
 
 ---
 
@@ -363,7 +365,7 @@ gitgo config get <key>
 | Key | Description | Default |
 |-----|-------------|---------|
 | `default-branch` | The branch used for push/link | `main` |
-| `default-message` | The commit message used for push | `New Project Update` |
+| `default-message` | The commit message used for push | `chore: new changes applied` |
 
 ### Global Flags
 
@@ -390,6 +392,8 @@ gitgo -r        # verify GitGo is ready
 
 Contributions are welcome. Read [CONTRIBUTING.md](CONTRIBUTING.md) for the full guide, including project structure, test instructions, commit conventions, and a [Good First Issues](CONTRIBUTING.md#good-first-issues) table if you're not sure where to start.
 
+If this is your first time contributing to an open-source project, follow our step-by-step [First Contribution Walkthrough](docs/first-contribution.md) guide.
+
 ---
 
 ## Credits

{pygitgo-1.8.2 → pygitgo-1.9.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pygitgo"
-version = "1.8.2"
+version = "1.9.0"
 description = "GitGo CLI - Your Fast Git Companion. Simplifies git push, link, stash, and user management."
 readme = "README.md"
 license = {text = "GPL-3.0-or-later"}
@@ -45,3 +45,4 @@ where = ["src"]
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 addopts = "--cov=pygitgo --cov-report=term-missing"
+pythonpath = ["src"]

{pygitgo-1.8.2 → pygitgo-1.9.0}/src/pygitgo/auth/account.py

@@ -41,9 +41,13 @@ def ensure_user_configure(default_email=None, default_username=None):
         set_user(default_username, default_email)
         return True
     
-    warning("\nGit user identity is not configured!")
-    info("This is required for your commits to be attributed correctly.")
-    
+    print()
+    print("  Git Identity Setup")
+    print("  " + "-" * 36)
+    warning("Git user identity is not configured.")
+    info("Needed so your commits are attributed to the right account.")
+    print()
+
     if default_username:
         new_username = default_username
         info(f"Using GitHub username: {new_username}")

{pygitgo-1.8.2 → pygitgo-1.9.0}/src/pygitgo/auth/manager.py

@@ -1,7 +1,7 @@
 from pygitgo.utils.cli_io import info, success, warning, error
 from pygitgo.utils.platform import get_platform
 from pygitgo.utils.executor import run_command
-from pygitgo.exceptions import GitCommandError
+from pygitgo.exceptions import GitCommandError, GitGoError
 from pygitgo.utils.platform import open_url
 from . import ssh_utils
 import os
@@ -44,7 +44,12 @@ def login():
         else:
             error("Please enter a valid email address.")
 
-    key_path = ssh_utils.generate_ssh_key(email=email)
+    try:
+        key_path = ssh_utils.generate_ssh_key(email=email)
+    except GitGoError as e:
+        error(str(e))
+        return False
+
     pub_key_path = str(key_path) + ".pub"
 
     with open(pub_key_path, "r") as f:
@@ -82,21 +87,23 @@ def login():
         github_username = ssh_utils.get_github_username()
         ensure_user_configure(default_email=email, default_username=github_username)
         return True
-    
-    error("Login Failed. The SSH key may not have been added to GitHub correctly.")
-    info("Possible causes:")
-    info("  1. The key was not pasted on GitHub")
-
-    if get_platform() == "windows":
-        info("  2. SSH agent is not running — run in PowerShell (as Administrator):")
-        info("       Set-Service ssh-agent -StartupType Automatic")
-        info("       Start-Service ssh-agent")
-        info("     Then run 'gitgo user login' again.")
-    else:
-        info("  2. SSH agent is not running (try: eval $(ssh-agent) && ssh-add)")
-        
-    info("  3. Network or firewall is blocking SSH connections")
-    info("Need help? Full guide: https://github.com/Huerte/GitGo/blob/main/docs/login-guide.md")
+
+    raw_output, timed_out, os_error = ssh_utils._get_cached_ssh_response()
+    cause = ssh_utils.classify_connection_error(raw_output, timed_out, os_error)
+
+    error("Login failed. GitHub did not accept the SSH key.")
+    info(f"Reason: {cause}")
+
+    if get_platform() == "windows" and not timed_out:
+        info("")
+        info("If the key was added correctly but still fails, the SSH agent may not be running.")
+        info("Fix (run PowerShell as Administrator):")
+        info("  Set-Service ssh-agent -StartupType Automatic")
+        info("  Start-Service ssh-agent")
+        info("Then run 'gitgo user login' again.")
+
+    info("")
+    info("Full guide: https://github.com/Huerte/GitGo/blob/main/docs/login-guide.md")
     return False
 
  

{pygitgo-1.8.2 → pygitgo-1.9.0}/src/pygitgo/auth/ssh_utils.py

@@ -48,9 +48,12 @@ def _get_github_ssh_response():
             capture_output=True, text=True,
             timeout=SSH_TIMEOUT_SECONDS, stdin=subprocess.DEVNULL,
         )
-        return (result.stderr or "") + (result.stdout or "")
-    except (subprocess.TimeoutExpired, OSError):
-        return None
+        combined = (result.stderr or "") + (result.stdout or "")
+        return combined, False, None
+    except subprocess.TimeoutExpired:
+        return "", True, None
+    except OSError as e:
+        return "", False, str(e)
 
 
 def _get_cached_ssh_response():
@@ -58,7 +61,7 @@ def _get_cached_ssh_response():
     if not _cache_populated:
         _cached_ssh_response = _get_github_ssh_response()
         _cache_populated = True
-    return _cached_ssh_response
+    return _cached_ssh_response  # (raw_output, timed_out, os_error)
 
 
 def clear_ssh_cache():
@@ -66,39 +69,57 @@ def clear_ssh_cache():
     _cached_ssh_response = None
     _cache_populated = False
 
+from typing import Optional
+def classify_connection_error(raw_output: str, timed_out: bool, os_error: Optional[str]) -> str:
+    """Return a specific, human-readable cause string based on the SSH response."""
+    if timed_out:
+        return "Connection timed out. GitHub SSH port (22) may be blocked by your network or firewall."
+    if os_error:
+        return f"Could not launch the SSH client: {os_error}"
+    if not raw_output:
+        return "No response from GitHub. Check your internet connection."
+    if "Permission denied" in raw_output:
+        return "Permission denied. The SSH key has not been added to your GitHub account, or it was added incorrectly."
+    if "Connection refused" in raw_output:
+        return "Connection refused on port 22. Try a network without strict firewall rules."
+    if "Host key verification failed" in raw_output:
+        return "Host key verification failed. Run: ssh-keyscan -H github.com >> ~/.ssh/known_hosts"
+    if "Could not resolve hostname" in raw_output:
+        return "DNS lookup failed. You may be offline or behind a restrictive proxy."
+    # Return the raw SSH message so users see the actual problem.
+    return raw_output.strip() or "Unknown SSH error."
+
 
 def check_connection(ok_text=None, fail_text=None):
     from yaspin import yaspin
     import sys
-    
+
     ensure_github_known_host()
 
-    kwargs = {"text": ok_text or "Verifying GitHub connection..."}
+    kwargs = {"text": "Verifying GitHub connection..."}
     if sys.stdout.isatty():
         kwargs["color"] = "cyan"
     spinner = yaspin(**kwargs)
     spinner.start()
 
-    output = _get_cached_ssh_response()
-    connected = output is not None and "successfully authenticated" in output
+    raw_output, timed_out, os_error = _get_cached_ssh_response()
+    connected = not timed_out and not os_error and "successfully authenticated" in raw_output
 
     if connected:
-        if ok_text:
-            spinner.text = ok_text
+        spinner.text = ok_text or "GitHub connection verified."
         spinner.ok("✔")
     else:
-        if fail_text:
-            spinner.text = fail_text
+        spinner.text = fail_text or "Could not connect to GitHub."
         spinner.fail("✖")
 
     return connected
 
 
 def get_github_username():
-    output = _get_cached_ssh_response()
-    if output and "Hi " in output and "!" in output:
+    raw_output, _timed_out, _os_error = _get_cached_ssh_response()
+    if raw_output and "Hi " in raw_output and "!" in raw_output:
         try:
-            return output.split("Hi ")[1].split("!")[0]
+            return raw_output.split("Hi ")[1].split("!")[0]
         except (IndexError, ValueError):
             pass
     return None

{pygitgo-1.8.2 → pygitgo-1.9.0}/src/pygitgo/commands/git_branch.py

@@ -1,14 +1,27 @@
-from pygitgo.utils.cli_io import success, error, info, confirm
+from pygitgo.utils.cli_io import warning, error, info, confirm
 from pygitgo.exceptions import GitCommandError, GitGoError
 from pygitgo.utils.executor import run_command
 from pygitgo.utils.config import get_config
 from argparse import Namespace
 
 
-def get_current_branch():
+def get_current_branch(safe=False):
     branch = run_command(["git", "branch", "--show-current"]).strip()
     if not branch:
-        branch = run_command(["git", "rev-parse", "--short", "HEAD"]).strip()
+        # We are in a detached HEAD state.
+        commit_hash = run_command(["git", "rev-parse", "--short", "HEAD"]).strip()
+        
+        if safe:
+            warning("You are in a 'detached HEAD' state (not on any branch).")
+            warning("If you switch away now, your current commits could be lost.")
+            if confirm("Would you like to create a new branch here to save your work? (y/n): "):
+                new_branch = input("Enter a name for the new branch: ").strip()
+                if new_branch:
+                    run_command(["git", "checkout", "-b", new_branch])
+                    return new_branch
+            raise GitGoError("Operation aborted to prevent data loss in detached HEAD state.")
+            
+        return commit_hash
     return branch
 
 

pygitgo-1.9.0/src/pygitgo/commands/git_core.py

@@ -0,0 +1,161 @@
+from pygitgo.auth.ssh_utils import convert_https_to_ssh, get_ssh_key_path, is_ssh_url, check_connection
+from pygitgo.exceptions import GitGoError, GitCommandError
+from pygitgo.auth.account import sanitize_signing_config
+from pygitgo.commands.git_remote import handle_rebase
+from pygitgo.utils.config import get_default_branch
+from pygitgo.utils.executor import run_command
+from pygitgo.utils.cli_io import info, warning
+import os
+
+
+
+def _get_signing_flags():
+    key_path = get_ssh_key_path()
+    if not key_path.exists():
+        return []
+    return [
+        "-c", "gpg.format=ssh",
+        "-c", f"user.signingkey={key_path}",
+    ]
+
+
+def git_commit(commit_message, loading_msg="Committing changes...", skip_staging=False, ok_text=None):
+    if not ok_text:
+        ok_text = "Changes committed."
+    try:
+        status_result = run_command(["git", "status", "--porcelain"])
+        if not status_result.strip():
+            return False
+    except GitCommandError as e:
+        stderr = getattr(e, "stderr", str(e))
+        if "not a git repository" in stderr.lower():
+            raise GitGoError("Not inside a git repository. Run 'gitgo init' or 'gitgo link' first.")
+        raise GitGoError(f"Could not check repository status: {stderr}")
+    
+    sanitize_signing_config()
+
+    if not skip_staging:
+        run_command(["git", "add", "."], loading_msg="Staging files...", ok_text="Files staged.")
+
+    clean_message = commit_message.strip('"\'')
+
+    signing_flags = _get_signing_flags()
+    commit_command = ["git"] + signing_flags + ["commit", "-S", "-m", clean_message]
+    run_command(commit_command, loading_msg=loading_msg, ok_text=ok_text)
+
+    return True
+
+
+def git_init(ok_text=None):
+    if os.path.isdir(".git"):
+        warning("Already a git repository! Skipping init...")
+        return False
+
+    default_main_branch = get_default_branch()
+
+    if not ok_text:
+        ok_text = "Git repository initialized."
+
+    try:
+        run_command(["git", "init", "-b", default_main_branch], loading_msg="Initializing git repository...", ok_text=ok_text)
+    except GitCommandError:
+        run_command(["git", "init"], loading_msg="Initializing git repository...")
+        run_command(["git", "checkout", "-b", default_main_branch], ok_text=ok_text)
+
+    return True
+
+
+def git_push(branch, ok_text=None):
+    if not ok_text:
+        ok_text = f"Pushed to remote branch '{branch}'."
+    try:
+        remote_url = run_command(["git", "remote", "get-url", "origin"]).strip()
+    except GitCommandError:
+        remote_url = None
+
+    if remote_url and not is_ssh_url(remote_url) and check_connection():
+        ssh_url = convert_https_to_ssh(remote_url)
+        if ssh_url:
+            run_command(["git", "remote", "set-url", "origin", ssh_url], loading_msg="Converting remote from HTTPS to SSH for secure push...", ok_text=f"Remote updated to: {ssh_url}")
+
+    try:
+        run_command(["git", "push", "-u", "origin", branch], loading_msg=f"Pushing to remote branch '{branch}'...", ok_text=ok_text, err_text="Push failed: verify your remote URL and SSH key, then try again.")
+    except (GitCommandError, OSError) as e:
+        stderr = getattr(e, "stderr", str(e))
+        if "rebase in progress" in stderr.lower():
+            handle_rebase()
+        elif "non-fast-forward" in stderr.lower() or "rejected" in stderr.lower():
+            info("The remote has commits you don't have locally.")
+            info("Run 'gitgo pull' first, then push again.")
+            raise GitGoError("Push rejected: pull the latest changes first.")
+        elif "repository not found" in stderr.lower() or "does not exist" in stderr.lower():
+            info("Run:  git remote -v   to verify the remote URL.")
+            raise GitGoError("Push failed: remote repository not found.")
+        elif "permission denied" in stderr.lower():
+            info("Check that your SSH key is added to GitHub.")
+            info("Run:  gitgo user login   to re-authenticate.")
+            raise GitGoError("Push failed: permission denied.")
+        else:
+            info("Run:  git remote -v   to inspect your current remote.")
+            raise GitGoError(f"Push failed: {stderr}" if stderr else "Push failed — check the output above.")
+
+
+def abort_pull_conflict():
+    from pathlib import Path
+    from pygitgo.utils.cli_io import warning, info, confirm
+    from pygitgo.exceptions import GitCommandError, GitGoError
+    from pygitgo.utils.executor import run_command
+    from pygitgo.commands.git_branch import get_current_branch
+    
+    rebase_in_progress = Path(".git/rebase-merge").exists() or Path(".git/rebase-apply").exists()
+    
+    if rebase_in_progress:
+        warning("A sync or jump hit a merge conflict and is paused.")
+        if not confirm("Cancel the sync and discard any conflict fixes? (y/n): ", destructive=True):
+            info("Canceled. The conflict is still active.")
+            return False
+            
+        try:
+            run_command(["git", "rebase", "--abort"], loading_msg="Aborting sync...", ok_text="Sync aborted. Branch is back to how it was before the conflict.")
+            return True
+        except GitCommandError as e:
+            raise GitGoError(f"Abort failed: {getattr(e, 'stderr', str(e))}")
+
+    try:
+        run_command(["git", "rev-parse", "ORIG_HEAD"])
+    except GitCommandError:
+        raise GitGoError(
+            "No pull to undo. ORIG_HEAD not found — this means no pull has been run yet."
+        )
+
+    try:
+        branch = get_current_branch(safe=True)
+    except GitCommandError as e:
+        raise GitGoError(f"Could not determine the current branch: {e}")
+
+    warning("This will reset your branch to the state before the last pull.")
+    warning("Any commits that arrived in the pull will be removed locally.")
+    if not confirm("Undo the last pull? Type 'y' to confirm: ", destructive=True):
+        info("Canceled. Branch is unchanged.")
+        return False
+
+    try:
+        run_command(
+            ["git", "reset", "--hard", "ORIG_HEAD"],
+            loading_msg="Reverting to pre-pull state...",
+            ok_text="Branch reset to its state before the last pull."
+        )
+    except GitCommandError as e:
+        raise GitGoError(f"Undo failed: {getattr(e, 'stderr', str(e))}")
+
+    try:
+        behind = run_command(["git", "rev-list", "--count", f"HEAD..origin/{branch}"]).strip()
+        if behind and int(behind) > 0:
+            warning(f"Your local branch is now {behind} commit(s) behind remote '{branch}'.")
+            info("The remote still has the pulled commits. Your local copy has been reset.")
+            info(f"To push your undo to the remote: git push --force origin {branch}")
+            info("Only do this if you are the only person working on this branch.")
+    except (GitCommandError, ValueError):
+        pass
+
+    return True

{pygitgo-1.8.2 → pygitgo-1.9.0}/src/pygitgo/commands/git_remote.py

@@ -20,9 +20,17 @@ def confirm_remote_link(ok_text=None):
     try:
         run_command(["git", "ls-remote", "origin"], loading_msg="Testing connection to remote...", ok_text=ok_text)
         return True
-    except GitCommandError:
+    except GitCommandError as e:
+        stderr = getattr(e, "stderr", str(e))
         info("Run:  git remote -v   to inspect your current remote.")
-        raise GitGoError("Connection failed — verify the URL and your SSH key.")
+        if "could not resolve" in stderr.lower():
+            raise GitGoError("Connection failed: DNS lookup failed for the remote host. Check your internet.")
+        elif "permission denied" in stderr.lower():
+            raise GitGoError("Connection failed: SSH key not accepted. Run 'gitgo user login' to re-authenticate.")
+        elif stderr:
+            raise GitGoError(f"Connection failed: {stderr}")
+        else:
+            raise GitGoError("Connection failed — verify the URL and your SSH key.")
 
 
 def check_and_sync_branch(branch):
@@ -56,6 +64,6 @@ def handle_rebase():
     warning("Conflict detected during rebase.")
     info("Resolve conflicts manually, then run:")
     info("    git add <files>")
-    info("    git rebase --continue")
+    info("    gitgo resolve")
     info("When finished, run 'gitgo push <branch> <message>' again.")
     raise GitGoError("Push aborted — rebase conflict in progress.")

{pygitgo-1.8.2 → pygitgo-1.9.0}/src/pygitgo/commands/init.py

@@ -1,6 +1,6 @@
 from pygitgo.commands.git_core import git_init
 from pygitgo.exceptions import GitGoError
-from pygitgo.utils.cli_io import info
+from pygitgo.utils.cli_io import info, warning
 import urllib.request
 import urllib.error
 import zipfile
@@ -320,8 +320,9 @@ def init_operation(args, standalone=False):
         if os.path.exists(target_dir) and not os.listdir(target_dir):
             try:
                 os.rmdir(target_dir)
-            except Exception:
-                pass
+            except Exception as cleanup_err:
+                warning(f"Could not remove empty folder '{target_dir}': {cleanup_err}")
+                warning(f"Delete it manually before running this command again.")
         raise e
     finally:
         os.chdir(orig_cwd)

{pygitgo-1.8.2 → pygitgo-1.9.0}/src/pygitgo/commands/jump.py

@@ -59,92 +59,101 @@ def _jump_interrupt_cleanup(original_branch, stashed_code, created_branch):
 
 def jump_operation(args):
     target_branch = args.branch
-    original_branch = get_current_branch()
+    original_branch = get_current_branch(safe=True)
 
     if original_branch == target_branch:
         warning(f"Already on branch '{target_branch}'.")
         return
 
     try:
-        has_changes = run_command(['git', 'status', '--porcelain'], loading_msg="Checking for uncommitted changes...")
-    except GitCommandError:
-        raise GitGoError("Unable to check for uncommitted changes — make sure you're in a valid git repository.")
+        has_changes = run_command(["git", "status", "--porcelain"], loading_msg="Checking for local changes...")
+    except GitCommandError as e:
+        stderr = getattr(e, "stderr", str(e))
+        if "not a git repository" in stderr.lower():
+            raise GitGoError("Not inside a git repository. Run 'gitgo init' or 'gitgo link' first.")
+        raise GitGoError(f"Could not check repository status: {stderr}")
 
     stashed_code = False
     created_branch = None
 
     try:
         if has_changes.strip():
-            print()
-            info("You have unsaved changes in this folder.")
-            if not confirm(f"Move your unsaved edits to branch '{target_branch}'? (y/n): "):
-                print()
-                warning("You cannot switch branches with unsaved edits. Jump canceled.")
-                return
-            stash_result = git_stash_push(label="GitGo Jump Auto-Stash", loading_msg="Saving your changes before jumping...")
+            stash_result = git_stash_push(label="GitGo Jump Auto-Stash", loading_msg="Auto-saving local changes before switching...")
             if not stash_result:
-                warning("Stash failed. Your working tree may have untracked files.")
-                info("Run:  git status   to see what's blocking the stash.")
-                raise GitGoError("Jump aborted: could not save working changes.")
-            info("Changes saved. Jumping to the new branch...")
+                from pathlib import Path
+                lock_file = Path(".git/index.lock")
+                if lock_file.exists():
+                    warning("A stale lock file is blocking git.")
+                    info(f"Delete this file and try again: {lock_file.absolute()}")
+                elif Path(".git/rebase-merge").exists() or Path(".git/rebase-apply").exists():
+                    warning("A rebase is in progress. Finish or abort it first.")
+                    info("Abort with:  gitgo resolve --abort")
+                else:
+                    warning("Could not auto-save changes before switching.")
+                    info("Run:  git status   to see what is blocking the stash.")
+                raise GitGoError("Jump aborted: could not save local changes.")
             stashed_code = True
 
         if not is_branch_exist(target_branch):
             print()
             warning(f"Branch '{target_branch}' does not exist.")
-            if not confirm(f"Branch '{target_branch}' does not exist yet. Create it and switch to it? (y/n): "):
-                info("Exiting without jumping...")
+            if not confirm(f"Create '{target_branch}' and switch to it? (y/n): "):
+                info("Jump canceled.")
                 if stashed_code:
-                    pop_result = git_stash_pop(loading_msg="Putting your unsaved changes back...")
+                    pop_result = git_stash_pop(loading_msg="Restoring your local changes...")
                     if not pop_result:
-                        warning("Could not restore your unsaved changes automatically. Run 'gitgo state list' to recover them.")
+                        warning("Could not restore changes automatically. Run 'gitgo state list' to recover them.")
                 return
 
             ok_text = f"Branch '{target_branch}' created." if stashed_code else f"On '{target_branch}'."
             git_new_branch(target_branch, ok_text=ok_text)
             created_branch = target_branch
         else:
-            if stashed_code:
-                run_command(['git', 'checkout', target_branch], loading_msg=f"Moving you to branch '{target_branch}'...", ok_text=f"Moved to branch '{target_branch}'.")
-                main_branch = get_main_branch()
-                try:
-                    run_command(['git', 'pull', 'origin', main_branch], loading_msg=f"Downloading the latest updates from '{main_branch}'...", ok_text=f"Downloaded updates from '{main_branch}'.")
-                except GitCommandError:
-                    warning(f"Failed to pull updates from '{main_branch}'. No internet, or the remote branch doesn't exist yet.")
-                    info(f"On '{target_branch}', but without the latest updates from '{main_branch}'.")
-            else:
-                run_command(['git', 'checkout', target_branch], loading_msg=f"Moving you to branch '{target_branch}'...", ok_text=f"Moved to branch '{target_branch}'.")
-                main_branch = get_main_branch()
-                try:
-                    run_command(['git', 'pull', 'origin', main_branch], loading_msg=f"Downloading the latest updates from '{main_branch}'...", ok_text=f"On '{target_branch}'. Up to date with '{main_branch}'.")
-                except GitCommandError:
-                    warning(f"Failed to pull updates from '{main_branch}'. No internet, or the remote branch doesn't exist yet.")
-                    info(f"On '{target_branch}', but without the latest updates from '{main_branch}'.")
+            run_command(
+                ["git", "checkout", target_branch],
+                loading_msg=f"Switching to '{target_branch}'...",
+                ok_text=f"Switched to '{target_branch}'."
+            )
+            main_branch = get_main_branch()
+            try:
+                run_command(
+                    ["git", "pull", "--rebase", "--autostash", "origin", main_branch],
+                    loading_msg=f"Syncing '{target_branch}' with latest from '{main_branch}'...",
+                    ok_text=f"'{target_branch}' is up to date with '{main_branch}'."
+                )
+            except GitCommandError as e:
+                stderr = getattr(e, "stderr", str(e))
+                if "conflict" in stderr.lower() or "rebase in progress" in stderr.lower():
+                    warning(f"Sync from '{main_branch}' hit a conflict.")
+                    info("Fix the conflict files, then run:  gitgo resolve")
+                    info("Or cancel the jump with:  gitgo resolve --abort")
+                else:
+                    warning(f"Could not sync from '{main_branch}': no remote or no internet.")
+                    info(f"On '{target_branch}', but not yet synced with '{main_branch}'.")
 
         if stashed_code:
-            apply_result = git_stash_apply(loading_msg="Unpacking your unsaved changes...")
+            apply_result = git_stash_apply(loading_msg="Restoring your local changes...")
             if not apply_result:
                 print()
-                error("MERGE CONFLICT — your changes clash with the target branch.")
+                error("CONFLICT: Your local changes clash with the target branch.")
                 print()
                 info("Option [Y]: Stay here and fix the conflict lines in your files.")
                 info("Option [N]: Undo the switch and go back to where you started.")
                 print()
-                if not confirm("Fix the conflicts yourself? (y = stay and fix / n = go back): "):
+                if not confirm("Fix the conflicts yourself? (y = stay / n = go back): "):
                     undo_jump_operation(original_branch, stashed_code, created_branch)
                     return
                 else:
                     print()
-                    success(f"On '{target_branch}'. Conflict markers are in your files.")
-                    warning("Open your editor and fix the conflict lines.")
-                    info("Your stash backup is still saved. Run 'gitgo state list' to see it.")
+                    success(f"On '{target_branch}'. Fix the conflict markers in your files.")
+                    warning("Your stash backup is still saved. Run 'gitgo state list' to see it.")
                     return
             else:
-                drop_result = git_stash_drop(loading_msg="Cleaning up the temporary stash...", ok_text=f"On '{target_branch}'. Your changes came with you.")
+                drop_result = git_stash_drop(loading_msg="Cleaning up temporary stash...", ok_text=f"On '{target_branch}'. Your changes came with you.")
                 if not drop_result:
                     warning("Could not clean up the temporary stash. Run 'gitgo state list' to remove it manually.")
 
-        if not getattr(args, 'nested', False):
+        if not getattr(args, "nested", False):
             banner("WORKSPACE RE-POSITIONED. TARGET DEPLOYMENT SECURED.", "ON TARGET BRANCH WITH RE-APPLIED STATE.")
         return
 
@@ -153,3 +162,4 @@ def jump_operation(args):
         warning("Jump interrupted (Ctrl+C).")
         _jump_interrupt_cleanup(original_branch, stashed_code, created_branch)
         sys.exit(130)
+