pygitgo 1.7.0__tar.gz → 1.7.1__tar.gz

{pygitgo-1.7.0/src/pygitgo.egg-info → pygitgo-1.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygitgo
-Version: 1.7.0
+Version: 1.7.1
 Summary: GitGo CLI - Your Fast Git Companion. Simplifies git push, link, stash, and user management.
 Author: Huerte
 License: GPL-3.0-or-later
@@ -88,7 +88,7 @@ gitgo link https://github.com/username/repo.git "init"
 ## Features
 
 - **Single commands for linking, pushing, and stashing.** No more chaining five commands together.
-- **Undo:** Roll back commits, unstage files, or discard local changes. The subcommands say what they do: `undo commit`, `undo add`, `undo changes`.
+- **Undo:** Roll back commits, unstage files, discard local changes, or revert pushes. The subcommands say what they do: `undo commit`, `undo add`, `undo changes`, `undo link`, `undo push`.
 - **Branch switching with `jump`:** Stashes your uncommitted work, moves to the target branch, syncs with main, and pops the stash. If a merge conflict occurs, the Try-and-Revert engine offers to roll the whole operation back.
 - **State management:** Named, indexed stash. Run `state list` to see what you saved. No more `stash@{2}` archaeology.
 - **Custom defaults:** Store your preferred branch name and default commit message. GitGo picks them up on every run.
@@ -195,6 +195,8 @@ Undo recent mistakes with commands named for what they undo.
 gitgo undo commit    # Undo the last commit (files stay staged)
 gitgo undo add       # Unstage files
 gitgo undo changes   # DANGER: permanently discard all uncommitted edits
+gitgo undo link      # Remove remote and undo initial commit
+gitgo undo push      # DANGER: Revert last push with a force-push
 ```
 
 ### 6. Save Your Work-in-Progress
@@ -270,6 +272,8 @@ Undo recent actions with subcommands named for what they undo.
 gitgo undo commit    # Undo the last commit without losing files
 gitgo undo add       # Unstage files
 gitgo undo changes   # Permanently discard all new files and uncommitted edits
+gitgo undo link      # Remove the remote and undo the initial commit
+gitgo undo push      # DANGER: Revert the last push with a force-push
 ```
 
 ### `gitgo state`

{pygitgo-1.7.0 → pygitgo-1.7.1}/README.md

@@ -63,7 +63,7 @@ gitgo link https://github.com/username/repo.git "init"
 ## Features
 
 - **Single commands for linking, pushing, and stashing.** No more chaining five commands together.
-- **Undo:** Roll back commits, unstage files, or discard local changes. The subcommands say what they do: `undo commit`, `undo add`, `undo changes`.
+- **Undo:** Roll back commits, unstage files, discard local changes, or revert pushes. The subcommands say what they do: `undo commit`, `undo add`, `undo changes`, `undo link`, `undo push`.
 - **Branch switching with `jump`:** Stashes your uncommitted work, moves to the target branch, syncs with main, and pops the stash. If a merge conflict occurs, the Try-and-Revert engine offers to roll the whole operation back.
 - **State management:** Named, indexed stash. Run `state list` to see what you saved. No more `stash@{2}` archaeology.
 - **Custom defaults:** Store your preferred branch name and default commit message. GitGo picks them up on every run.
@@ -170,6 +170,8 @@ Undo recent mistakes with commands named for what they undo.
 gitgo undo commit    # Undo the last commit (files stay staged)
 gitgo undo add       # Unstage files
 gitgo undo changes   # DANGER: permanently discard all uncommitted edits
+gitgo undo link      # Remove remote and undo initial commit
+gitgo undo push      # DANGER: Revert last push with a force-push
 ```
 
 ### 6. Save Your Work-in-Progress
@@ -245,6 +247,8 @@ Undo recent actions with subcommands named for what they undo.
 gitgo undo commit    # Undo the last commit without losing files
 gitgo undo add       # Unstage files
 gitgo undo changes   # Permanently discard all new files and uncommitted edits
+gitgo undo link      # Remove the remote and undo the initial commit
+gitgo undo push      # DANGER: Revert the last push with a force-push
 ```
 
 ### `gitgo state`

{pygitgo-1.7.0 → pygitgo-1.7.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pygitgo"
-version = "1.7.0"
+version = "1.7.1"
 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"}

{pygitgo-1.7.0 → pygitgo-1.7.1}/src/pygitgo/commands/git_core.py

@@ -1,9 +1,9 @@
 from pygitgo.auth.ssh_utils import convert_https_to_ssh, get_ssh_key_path, is_ssh_url, check_connection
 from pygitgo.utils.colors import info, success, warning, error
 from pygitgo.exceptions import GitGoError, GitCommandError
-from pygitgo.utils.executor import run_command
-from pygitgo.utils.config import get_config
 from pygitgo.commands.git_remote import handle_rebase
+from pygitgo.utils.config import get_default_branch
+from pygitgo.utils.executor import run_command
 import os
 
 
@@ -43,7 +43,7 @@ def git_init():
         warning("Already a git repository! Skipping init...")
         return False
 
-    default_main_branch = get_config("default-branch", "main")
+    default_main_branch = get_default_branch()
 
     try:
         run_command(["git", "init", "-b", default_main_branch], loading_msg="Initializing git repository...")

{pygitgo-1.7.0 → pygitgo-1.7.1}/src/pygitgo/commands/link.py

@@ -1,11 +1,11 @@
-from pygitgo.utils.colors import success, warning, error, highlight, info, print_banner
 from pygitgo.commands.git_remote import add_remote_origin, confirm_remote_link
+from pygitgo.utils.colors import success, warning, error, info, print_banner
 from pygitgo.commands.git_core import git_init, git_commit, git_push
 from pygitgo.commands.git_branch import get_current_branch
 from pygitgo.exceptions import GitCommandError, GitGoError
-from pygitgo.utils.executor import run_command
-from pygitgo.utils.config import get_config
 from pygitgo.utils.validators import validate_repo_url
+from pygitgo.utils.config import get_default_branch
+from pygitgo.utils.executor import run_command
 import sys
 
 
@@ -42,10 +42,6 @@ def link_operation(args):
 
     commit_message = args.message
 
-    highlight("INITIATING LINK OPERATION...")
-    highlight(f"Target: {repo_url}")
-    print()
-
     initialized = False
     committed = False
     remote_added = False
@@ -76,7 +72,7 @@ def link_operation(args):
             return
 
         current_branch = get_current_branch()
-        main_branch = get_config("default-branch", "main")
+        main_branch = get_default_branch()
 
         if current_branch != main_branch:
             run_command(["git", "branch", "-m", main_branch], loading_msg=f"Renaming branch '{current_branch}' to '{main_branch}'...")
@@ -100,14 +96,12 @@ def link_operation(args):
                 warning(f"Then: gitgo push {main_branch} 'your message'\n")
                 return
 
-        print_banner("REPOSITORY INITIALIZED AND LINKED.")
-
         git_push(current_branch)
 
         print_banner("REPOSITORY INITIALIZED AND DEPLOYED.")
 
         print()
-        info("Run 'gitgo undo commit' to revert this push if the deploy was unintended.")
+        info("Run 'gitgo undo link' to remove the remote and undo the initial commit.")
 
     except KeyboardInterrupt:
         print()

{pygitgo-1.7.0 → pygitgo-1.7.1}/src/pygitgo/commands/pull.py

@@ -27,7 +27,7 @@ def _pull_interrupt_cleanup():
         stash_list = run_command(["git", "stash", "list"])
         if stash_list and "autostash" in stash_list.lower():
             info("An autostash entry was found. Your local changes are safe.")
-            info("Run 'gitgo state list' to view it, or 'gitgo state load 1' to restore it.")
+            info("Run 'gitgo state list' to find it, then 'gitgo state load <id>' to restore it.")
     except GitCommandError:
         pass
 

{pygitgo-1.7.0 → pygitgo-1.7.1}/src/pygitgo/commands/push.py

@@ -26,7 +26,7 @@ def _push_interrupt_cleanup(original_branch, original_head, created_branch):
     if commit_was_made:
         info(f"Commit was saved locally on '{current_branch}' but was not pushed.")
         info("Run 'gitgo push' to retry the push.")
-        info("Run 'gitgo undo commit' to undo the commit instead.")
+        info("Run 'gitgo undo commit' to undo the local commit instead.")
         return
 
     try:
@@ -141,10 +141,12 @@ def push_operation(args):
 
         print_banner("MISSION COMPLETE. ALL TARGETS COMMITTED AND PUSHED.")
 
+        print()
         if auto_switched_from:
-            print()
             info(f"Switched from '{auto_switched_from}' to '{branch}' automatically.")
-            info(f"Run 'gitgo undo commit' then 'gitgo jump {auto_switched_from}' to revert this push and return.")
+            info(f"Run 'gitgo undo push' to revert the push, then 'gitgo jump {auto_switched_from}' to return.")
+        else:
+            info("Run 'gitgo undo push' to revert this push if it was unintended.")
 
     except KeyboardInterrupt:
         print()

pygitgo-1.7.1/src/pygitgo/commands/undo.py

@@ -0,0 +1,114 @@
+from pygitgo.commands.git_branch import get_current_branch
+from pygitgo.utils.colors import success, warning, info, error
+from pygitgo.exceptions import GitCommandError, GitGoError
+from pygitgo.utils.executor import run_command
+import sys
+
+
+def undo_commit():
+    try:
+        run_command(["git", "reset", "--soft", "HEAD~"])
+        success("Last commit undone. Files are untouched.")
+    except GitCommandError as e:
+        raise GitGoError(
+            f"Undo failed — no previous commit to revert. Details: {e}"
+        )
+
+
+def undo_add():
+    run_command(["git", "reset", "HEAD"])
+    success("Staging cleared. Files are back to unstaged.")
+
+
+def undo_changes():
+    error("DANGER: This will permanently delete all your new edits and new files!")
+    warning("This action cannot be undone.")
+    confirm = input("Are you sure you want to throw away all changes? (y/n): ")
+    if confirm.lower() != "y":
+        info("Canceled. Your files are safe.")
+        return
+
+    reset_done = False
+    try:
+        run_command(["git", "reset", "--hard", "HEAD"], loading_msg="Throwing away edits...")
+        reset_done = True
+        run_command(["git", "clean", "-fd"], loading_msg="Removing new files...")
+        success("Working tree reset. All changes discarded.")
+
+    except KeyboardInterrupt:
+        print()
+        if reset_done:
+            warning("Interrupted during file removal. Finishing cleanup...")
+            try:
+                run_command(["git", "clean", "-fd"])
+                success("Working tree reset. All changes discarded.")
+            except GitCommandError:
+                warning("Could not finish cleanup. Run 'git clean -fd' manually.")
+        else:
+            success("Reset canceled before any changes were made. Your files are safe.")
+        sys.exit(130)
+
+
+def undo_link():
+    try:
+        run_command(["git", "remote", "remove", "origin"])
+        success("Remote 'origin' removed.")
+    except GitCommandError as e:
+        raise GitGoError(
+            f"Could not remove remote 'origin'. Is one set? Details: {e}"
+        )
+
+    try:
+        run_command(["git", "reset", "--soft", "HEAD~"])
+        success("Initial commit undone. Files are back to staged, ready to re-link.")
+    except GitCommandError:
+        info("Remote removed. Could not undo the commit (none or multiple found).")
+        info("Run 'gitgo undo commit' separately if needed.")
+
+
+def undo_push():
+    try:
+        branch = get_current_branch()
+    except GitCommandError as e:
+        raise GitGoError(f"Could not determine the current branch: {e}")
+
+    error("DANGER: This force-pushes to the remote. Other collaborators will be affected.")
+    warning("Only use this if no one else has pulled the commit you are reverting.")
+    confirm = input("Are you sure you want to undo the last push? (y/n): ")
+    if confirm.lower() != "y":
+        info("Canceled. Remote is unchanged.")
+        return
+
+    try:
+        run_command(["git", "reset", "--soft", "HEAD~"], loading_msg="Reverting last commit locally...")
+    except GitCommandError as e:
+        raise GitGoError(f"Undo failed — no previous commit to revert. Details: {e}")
+
+    try:
+        run_command(
+            ["git", "push", "--force", "origin", branch],
+            loading_msg=f"Force-pushing reverted state to '{branch}'..."
+        )
+        success(f"Last push reverted. Remote '{branch}' is back to the previous commit.")
+        info("Your files are still staged locally. Edit and push again when ready.")
+    except GitCommandError as e:
+        warning("Local commit was undone, but the force-push failed.")
+        warning(f"Run manually: git push --force origin {branch}")
+        raise GitGoError(f"Force-push failed: {e}")
+
+
+def undo_operation(args):
+    action = args.action
+
+    if action == "commit":
+        undo_commit()
+    elif action == "add":
+        undo_add()
+    elif action == "changes":
+        undo_changes()
+    elif action == "link":
+        undo_link()
+    elif action == "push":
+        undo_push()
+    else:
+        raise GitGoError(f"Unknown undo operation: {action}")

{pygitgo-1.7.0 → pygitgo-1.7.1}/src/pygitgo/main.py

@@ -1,4 +1,4 @@
-from pygitgo.utils.update_checker import check_for_updates_background
+from pygitgo.utils.update_checker import check_for_updates_background, check_for_updates
 from pygitgo.utils.bootstrap import ensure_first_run_setup
 from pygitgo.utils.colors import info, warning, error
 from pygitgo.commands.config import config_operation
@@ -123,14 +123,16 @@ def main():
             "Examples:\n"
             "  gitgo undo commit       Undo your last commit (your files are safe)\n"
             "  gitgo undo add          Undo 'git add' (files are no longer ready to commit)\n"
-            "  gitgo undo changes      DANGER: Throw away all new changes and start fresh"
+            "  gitgo undo changes      DANGER: Throw away all new changes and start fresh\n"
+            "  gitgo undo link         Remove the remote and undo the initial commit\n"
+            "  gitgo undo push         DANGER: Revert the last push with a force-push"
         ), 
         formatter_class=argparse.RawDescriptionHelpFormatter
     )
     undo_parser.add_argument(
         "action", 
-        choices=["commit", "add", "changes"], 
-        help="What to undo: 'commit', 'add', or 'changes'"
+        choices=["commit", "add", "changes", "link", "push"], 
+        help="What to undo: 'commit', 'add', 'changes', 'link', or 'push'"
     )
 
     pull_parser = subparsers.add_parser("pull", 
@@ -147,12 +149,15 @@ def main():
     args = parser.parse_args()
 
     if getattr(args, 'version', False):
-        print(f"GitGo {get_version()}")
+        current_v = get_version()
+        print(f"GitGo {current_v}")
         print(f"Support GitGo: https://ko-fi.com/huerte")
+        check_for_updates(current_v)
         return
 
     if args.ready:
         info("ALL UNITS ONLINE. GitGo STANDING BY. AWAITING COMMANDS...")
+        check_for_updates(get_version())
         return
 
     if not args.command:

{pygitgo-1.7.0 → pygitgo-1.7.1}/src/pygitgo/utils/config.py

@@ -1,29 +1,44 @@
-from pygitgo.utils.executor import run_command
-from pygitgo.utils.colors import error, warning, success, info
-from pygitgo.exceptions import GitCommandError
-
-
-def get_config(key, fallback_value):
-
-    config_key = f"gitgo.{key}"
-
-    try:
-        result = run_command(['git', 'config', '--global', config_key])                                                                                                                     
-        return result.strip()
-    except GitCommandError:
-        return fallback_value
-
-
-def set_config(key, value):
-
-    config_key = f"gitgo.{key}"
-
-    try:
-        result = run_command(['git', 'config', '--global', config_key, value])
-        success(f"\nConfiguration saved: {key} = '{value}'")
-        return True
-    except GitCommandError:
-        error(f"\nFailed to save configuration for '{key}'.")
-        return False 
-
-
+from pygitgo.utils.executor import run_command
+from pygitgo.utils.colors import error, warning, success, info
+from pygitgo.exceptions import GitCommandError
+import subprocess
+
+
+def get_config(key, fallback_value):
+
+    config_key = f"gitgo.{key}"
+
+    try:
+        result = run_command(['git', 'config', '--global', config_key])                                                                                                                     
+        return result.strip()
+    except GitCommandError:
+        return fallback_value
+
+
+def set_config(key, value):
+
+    config_key = f"gitgo.{key}"
+
+    try:
+        result = run_command(['git', 'config', '--global', config_key, value])
+        success(f"\nConfiguration saved: {key} = '{value}'")
+        return True
+    except GitCommandError:
+        error(f"\nFailed to save configuration for '{key}'.")
+        return False
+
+
+def get_default_branch() -> str:
+    try:
+        branch = subprocess.check_output(
+            ["git", "config", "--get", "init.defaultBranch"],
+            text=True,
+            stderr=subprocess.DEVNULL,
+        ).strip()
+        if branch:
+            return branch
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        pass
+
+    return get_config("default-branch", "main")
+

{pygitgo-1.7.0 → pygitgo-1.7.1/src/pygitgo.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygitgo
-Version: 1.7.0
+Version: 1.7.1
 Summary: GitGo CLI - Your Fast Git Companion. Simplifies git push, link, stash, and user management.
 Author: Huerte
 License: GPL-3.0-or-later
@@ -88,7 +88,7 @@ gitgo link https://github.com/username/repo.git "init"
 ## Features
 
 - **Single commands for linking, pushing, and stashing.** No more chaining five commands together.
-- **Undo:** Roll back commits, unstage files, or discard local changes. The subcommands say what they do: `undo commit`, `undo add`, `undo changes`.
+- **Undo:** Roll back commits, unstage files, discard local changes, or revert pushes. The subcommands say what they do: `undo commit`, `undo add`, `undo changes`, `undo link`, `undo push`.
 - **Branch switching with `jump`:** Stashes your uncommitted work, moves to the target branch, syncs with main, and pops the stash. If a merge conflict occurs, the Try-and-Revert engine offers to roll the whole operation back.
 - **State management:** Named, indexed stash. Run `state list` to see what you saved. No more `stash@{2}` archaeology.
 - **Custom defaults:** Store your preferred branch name and default commit message. GitGo picks them up on every run.
@@ -195,6 +195,8 @@ Undo recent mistakes with commands named for what they undo.
 gitgo undo commit    # Undo the last commit (files stay staged)
 gitgo undo add       # Unstage files
 gitgo undo changes   # DANGER: permanently discard all uncommitted edits
+gitgo undo link      # Remove remote and undo initial commit
+gitgo undo push      # DANGER: Revert last push with a force-push
 ```
 
 ### 6. Save Your Work-in-Progress
@@ -270,6 +272,8 @@ Undo recent actions with subcommands named for what they undo.
 gitgo undo commit    # Undo the last commit without losing files
 gitgo undo add       # Unstage files
 gitgo undo changes   # Permanently discard all new files and uncommitted edits
+gitgo undo link      # Remove the remote and undo the initial commit
+gitgo undo push      # DANGER: Revert the last push with a force-push
 ```
 
 ### `gitgo state`

{pygitgo-1.7.0 → pygitgo-1.7.1}/tests/test_config_utils.py

@@ -1,4 +1,4 @@
-from pygitgo.utils.config import get_config, set_config
+from pygitgo.utils.config import get_config, set_config, get_default_branch
 import subprocess
 
 
@@ -55,3 +55,50 @@ def test_get_config_error_handling(mocker):
     fake_run = mocker.patch('pygitgo.utils.config.run_command', side_effect=GitCommandError(['git']))
     result = get_config("default-key", "fallback")
     assert result == "fallback"
+
+
+# --- get_default_branch tests ---
+
+def test_get_default_branch_uses_git_init_default_branch(mocker):
+    # Level 1: native git config wins over gitgo config and hard fallback.
+    mocker.patch(
+        "pygitgo.utils.config.subprocess.check_output",
+        return_value="develop\n",
+    )
+    result = get_default_branch()
+    assert result == "develop"
+
+
+def test_get_default_branch_falls_back_to_gitgo_config(mocker):
+    # Level 2: init.defaultBranch unset, gitgo.default-branch is set.
+    mocker.patch(
+        "pygitgo.utils.config.subprocess.check_output",
+        side_effect=subprocess.CalledProcessError(1, "git"),
+    )
+    mocker.patch("pygitgo.utils.config.run_command", return_value="trunk")
+    result = get_default_branch()
+    assert result == "trunk"
+
+
+def test_get_default_branch_hard_fallback_to_main(mocker):
+    # Level 3: both sources absent, returns "main".
+    mocker.patch(
+        "pygitgo.utils.config.subprocess.check_output",
+        side_effect=subprocess.CalledProcessError(1, "git"),
+    )
+    from pygitgo.exceptions import GitCommandError
+    mocker.patch("pygitgo.utils.config.run_command", side_effect=GitCommandError(["git"]))
+    result = get_default_branch()
+    assert result == "main"
+
+
+def test_get_default_branch_handles_git_not_found(mocker):
+    # FileNotFoundError when git is not on PATH should not crash.
+    mocker.patch(
+        "pygitgo.utils.config.subprocess.check_output",
+        side_effect=FileNotFoundError,
+    )
+    from pygitgo.exceptions import GitCommandError
+    mocker.patch("pygitgo.utils.config.run_command", side_effect=GitCommandError(["git"]))
+    result = get_default_branch()
+    assert result == "main"

{pygitgo-1.7.0 → pygitgo-1.7.1}/tests/test_git_core.py

@@ -30,7 +30,7 @@ def test_git_init_already_initialized(mocker):
 
 def test_git_init_success(mocker):
     mocker.patch('os.path.isdir', return_value=False)
-    mocker.patch('pygitgo.commands.git_core.get_config', return_value='main')
+    mocker.patch('pygitgo.commands.git_core.get_default_branch', return_value='main')
     fake_success = mocker.patch('pygitgo.commands.git_core.success')
     fake_run = mocker.patch('pygitgo.commands.git_core.run_command', return_value='ok')
 
@@ -46,7 +46,7 @@ def test_git_init_success(mocker):
 def test_git_init_fallback(mocker):
     from pygitgo.exceptions import GitCommandError
     mocker.patch('os.path.isdir', return_value=False)
-    mocker.patch('pygitgo.commands.git_core.get_config', return_value='main')
+    mocker.patch('pygitgo.commands.git_core.get_default_branch', return_value='main')
     fake_success = mocker.patch('pygitgo.commands.git_core.success')
     
     fake_run = mocker.patch(

{pygitgo-1.7.0 → pygitgo-1.7.1}/tests/test_link.py

@@ -35,10 +35,10 @@ def test_link_new_repo_no_remote_refs(mocker):
     fake_add_remote = mocker.patch("pygitgo.commands.link.add_remote_origin")
     mocker.patch("pygitgo.commands.link.confirm_remote_link", return_value=True)
     mocker.patch("pygitgo.commands.link.get_current_branch", return_value="master")
-    mocker.patch("pygitgo.commands.link.get_config", return_value="main")
+    mocker.patch("pygitgo.commands.link.get_default_branch", return_value="main")
     fake_push = mocker.patch("pygitgo.commands.link.git_push")
 
-    fake_run = mocker.patch("pygitgo.commands.link.run_command", return_value="")  # remote_refs is empty
+    fake_run = mocker.patch("pygitgo.commands.link.run_command", return_value="")
 
     args = Namespace(url="git@github.com:user/repo.git", message="Initial commit")
     link_operation(args)
@@ -57,7 +57,7 @@ def test_link_new_repo_with_remote_refs_pull_success(mocker):
     mocker.patch("pygitgo.commands.link.add_remote_origin")
     mocker.patch("pygitgo.commands.link.confirm_remote_link", return_value=True)
     mocker.patch("pygitgo.commands.link.get_current_branch", return_value="main")
-    mocker.patch("pygitgo.commands.link.get_config", return_value="main")
+    mocker.patch("pygitgo.commands.link.get_default_branch", return_value="main")
     fake_push = mocker.patch("pygitgo.commands.link.git_push")
     fake_success = mocker.patch("pygitgo.commands.link.success")
 
@@ -87,7 +87,7 @@ def test_link_new_repo_with_remote_refs_pull_failure(mocker):
     mocker.patch("pygitgo.commands.link.add_remote_origin")
     mocker.patch("pygitgo.commands.link.confirm_remote_link", return_value=True)
     mocker.patch("pygitgo.commands.link.get_current_branch", return_value="main")
-    mocker.patch("pygitgo.commands.link.get_config", return_value="main")
+    mocker.patch("pygitgo.commands.link.get_default_branch", return_value="main")
     fake_error = mocker.patch("pygitgo.commands.link.error")
     fake_warning = mocker.patch("pygitgo.commands.link.warning")
 

{pygitgo-1.7.0 → pygitgo-1.7.1}/tests/test_push.py

@@ -39,7 +39,7 @@ def test_push_wrong_branch_auto_switch(mocker):
 
     fake_info.assert_any_call("Switching to target branch 'feature-branch'...")
     fake_info.assert_any_call("Switched from 'main' to 'feature-branch' automatically.")
-    fake_info.assert_any_call("Run 'gitgo undo commit' then 'gitgo jump main' to revert this push and return.")
+    fake_info.assert_any_call("Run 'gitgo undo push' to revert the push, then 'gitgo jump main' to return.")
     jump_args = fake_jump.call_args[0][0]
     assert jump_args.branch == "feature-branch"
     fake_commit.assert_called_once_with("Init commit")

pygitgo-1.7.1/tests/test_undo.py

@@ -0,0 +1,172 @@
+import pytest
+from unittest.mock import patch, MagicMock, call
+from pygitgo.commands.undo import undo_commit, undo_add, undo_changes, undo_link, undo_push, undo_operation
+from pygitgo.exceptions import GitGoError, GitCommandError
+from argparse import Namespace
+
+
+@patch("pygitgo.commands.undo.run_command")
+@patch("pygitgo.commands.undo.success")
+def test_undo_commit_success(mock_success, mock_run_command):
+    undo_commit()
+    mock_run_command.assert_called_once_with(["git", "reset", "--soft", "HEAD~"])
+    mock_success.assert_called_once()
+
+
+@patch("pygitgo.commands.undo.run_command")
+def test_undo_commit_failure(mock_run_command):
+    mock_run_command.side_effect = GitCommandError(["git", "reset", "--soft", "HEAD~"])
+    with pytest.raises(GitGoError):
+        undo_commit()
+    mock_run_command.assert_called_once()
+
+
+@patch("pygitgo.commands.undo.run_command")
+@patch("pygitgo.commands.undo.success")
+def test_undo_add_success(mock_success, mock_run_command):
+    undo_add()
+    mock_run_command.assert_called_once_with(["git", "reset", "HEAD"])
+    mock_success.assert_called_once()
+
+
+@patch("pygitgo.commands.undo.run_command")
+def test_undo_add_failure(mock_run_command):
+    mock_run_command.side_effect = GitCommandError(["git", "reset", "HEAD"])
+    with pytest.raises(GitCommandError):
+        undo_add()
+    mock_run_command.assert_called_once()
+
+
+@patch("pygitgo.commands.undo.run_command")
+@patch("pygitgo.commands.undo.success")
+@patch("pygitgo.commands.undo.input", return_value="y")
+def test_undo_changes_success(mock_input, mock_success, mock_run_command):
+    undo_changes()
+    mock_input.assert_called_once()
+    assert mock_run_command.call_count == 2
+    mock_run_command.assert_any_call(["git", "reset", "--hard", "HEAD"], loading_msg="Throwing away edits...")
+    mock_run_command.assert_any_call(["git", "clean", "-fd"], loading_msg="Removing new files...")
+    mock_success.assert_called_once()
+
+
+@patch("pygitgo.commands.undo.run_command")
+@patch("pygitgo.commands.undo.info")
+@patch("pygitgo.commands.undo.input", return_value="n")
+def test_undo_changes_abort(mock_input, mock_info, mock_run_command):
+    undo_changes()
+    mock_input.assert_called_once()
+    mock_info.assert_called_once()
+    mock_run_command.assert_not_called()
+
+
+# --- undo_link tests ---
+
+@patch("pygitgo.commands.undo.run_command")
+@patch("pygitgo.commands.undo.success")
+def test_undo_link_success(mock_success, mock_run_command):
+    undo_link()
+    mock_run_command.assert_any_call(["git", "remote", "remove", "origin"])
+    mock_run_command.assert_any_call(["git", "reset", "--soft", "HEAD~"])
+    assert mock_success.call_count == 2
+
+
+@patch("pygitgo.commands.undo.run_command")
+def test_undo_link_no_remote(mock_run_command):
+    mock_run_command.side_effect = GitCommandError(["git", "remote", "remove", "origin"])
+    with pytest.raises(GitGoError, match="Could not remove remote"):
+        undo_link()
+
+
+@patch("pygitgo.commands.undo.run_command")
+@patch("pygitgo.commands.undo.success")
+@patch("pygitgo.commands.undo.info")
+def test_undo_link_no_commit_to_reset(mock_info, mock_success, mock_run_command):
+    # First call (remote remove) succeeds, second (reset) fails.
+    mock_run_command.side_effect = [None, GitCommandError(["git", "reset"])]
+    undo_link()
+    mock_success.assert_called_once_with("Remote 'origin' removed.")
+    assert mock_info.call_count == 2
+
+
+# --- undo_push tests ---
+
+@patch("pygitgo.commands.undo.run_command")
+@patch("pygitgo.commands.undo.get_current_branch", return_value="main")
+@patch("pygitgo.commands.undo.success")
+@patch("pygitgo.commands.undo.input", return_value="y")
+def test_undo_push_success(mock_input, mock_success, mock_branch, mock_run_command):
+    undo_push()
+    mock_run_command.assert_any_call(["git", "reset", "--soft", "HEAD~"], loading_msg="Reverting last commit locally...")
+    mock_run_command.assert_any_call(["git", "push", "--force", "origin", "main"], loading_msg="Force-pushing reverted state to 'main'...")
+    mock_success.assert_called_once()
+
+
+@patch("pygitgo.commands.undo.run_command")
+@patch("pygitgo.commands.undo.get_current_branch", return_value="main")
+@patch("pygitgo.commands.undo.info")
+@patch("pygitgo.commands.undo.input", return_value="n")
+def test_undo_push_abort(mock_input, mock_info, mock_branch, mock_run_command):
+    undo_push()
+    mock_run_command.assert_not_called()
+    mock_info.assert_called_once_with("Canceled. Remote is unchanged.")
+
+
+@patch("pygitgo.commands.undo.run_command")
+@patch("pygitgo.commands.undo.get_current_branch", return_value="main")
+@patch("pygitgo.commands.undo.input", return_value="y")
+def test_undo_push_no_commit(mock_input, mock_branch, mock_run_command):
+    mock_run_command.side_effect = GitCommandError(["git", "reset"])
+    with pytest.raises(GitGoError, match="Undo failed"):
+        undo_push()
+
+
+@patch("pygitgo.commands.undo.run_command")
+@patch("pygitgo.commands.undo.get_current_branch", return_value="main")
+@patch("pygitgo.commands.undo.input", return_value="y")
+def test_undo_push_force_push_fails(mock_input, mock_branch, mock_run_command):
+    mock_run_command.side_effect = [None, GitCommandError(["git", "push", "--force"])]
+    with pytest.raises(GitGoError, match="Force-push failed"):
+        undo_push()
+
+
+# --- undo_operation routing tests ---
+
+@patch("pygitgo.commands.undo.undo_commit")
+def test_undo_operation_commit(mock_undo_commit):
+    args = Namespace(action="commit")
+    undo_operation(args)
+    mock_undo_commit.assert_called_once()
+
+
+@patch("pygitgo.commands.undo.undo_add")
+def test_undo_operation_add(mock_undo_add):
+    args = Namespace(action="add")
+    undo_operation(args)
+    mock_undo_add.assert_called_once()
+
+
+@patch("pygitgo.commands.undo.undo_changes")
+def test_undo_operation_changes(mock_undo_changes):
+    args = Namespace(action="changes")
+    undo_operation(args)
+    mock_undo_changes.assert_called_once()
+
+
+@patch("pygitgo.commands.undo.undo_link")
+def test_undo_operation_link(mock_undo_link):
+    args = Namespace(action="link")
+    undo_operation(args)
+    mock_undo_link.assert_called_once()
+
+
+@patch("pygitgo.commands.undo.undo_push")
+def test_undo_operation_push(mock_undo_push):
+    args = Namespace(action="push")
+    undo_operation(args)
+    mock_undo_push.assert_called_once()
+
+
+def test_undo_operation_invalid():
+    args = Namespace(action="invalid")
+    with pytest.raises(GitGoError):
+        undo_operation(args)

pygitgo-1.7.0/src/pygitgo/commands/undo.py

@@ -1,61 +0,0 @@
-from pygitgo.utils.colors import success, warning, info, error
-from pygitgo.exceptions import GitCommandError, GitGoError
-from pygitgo.utils.executor import run_command
-import sys
-
-
-def undo_commit():
-    try:
-        run_command(["git", "reset", "--soft", "HEAD~"])
-        success("Last commit undone. Files are untouched.")
-    except GitCommandError as e:
-        raise GitGoError(
-            f"Undo failed — no previous commit to revert. Details: {e}"
-        )
-
-
-def undo_add():
-    run_command(["git", "reset", "HEAD"])
-    success("Staging cleared. Files are back to unstaged.")
-
-
-def undo_changes():
-    error("DANGER: This will permanently delete all your new edits and new files!")
-    warning("This action cannot be undone.")
-    confirm = input("Are you sure you want to throw away all changes? (y/n): ")
-    if confirm.lower() != "y":
-        info("Canceled. Your files are safe.")
-        return
-
-    reset_done = False
-    try:
-        run_command(["git", "reset", "--hard", "HEAD"], loading_msg="Throwing away edits...")
-        reset_done = True
-        run_command(["git", "clean", "-fd"], loading_msg="Removing new files...")
-        success("Working tree reset. All changes discarded.")
-
-    except KeyboardInterrupt:
-        print()
-        if reset_done:
-            warning("Interrupted during file removal. Finishing cleanup...")
-            try:
-                run_command(["git", "clean", "-fd"])
-                success("Working tree reset. All changes discarded.")
-            except GitCommandError:
-                warning("Could not finish cleanup. Run 'git clean -fd' manually.")
-        else:
-            success("Reset canceled before any changes were made. Your files are safe.")
-        sys.exit(130)
-
-
-def undo_operation(args):
-    action = args.action
-
-    if action == "commit":
-        undo_commit()
-    elif action == "add":
-        undo_add()
-    elif action == "changes":
-        undo_changes()
-    else:
-        raise GitGoError(f"Unknown undo operation: {action}")

pygitgo-1.7.0/tests/test_undo.py

@@ -1,85 +0,0 @@
-import pytest
-from unittest.mock import patch, MagicMock
-from pygitgo.commands.undo import undo_commit, undo_add, undo_changes, undo_operation
-from pygitgo.exceptions import GitGoError, GitCommandError
-from argparse import Namespace
-
-@patch("pygitgo.commands.undo.run_command")
-@patch("pygitgo.commands.undo.success")
-def test_undo_commit_success(mock_success, mock_run_command):
-    undo_commit()
-    mock_run_command.assert_called_once_with(["git", "reset", "--soft", "HEAD~"])
-    mock_success.assert_called_once()
-
-
-@patch("pygitgo.commands.undo.run_command")
-def test_undo_commit_failure(mock_run_command):
-    mock_run_command.side_effect = GitCommandError(["git", "reset", "--soft", "HEAD~"])
-    with pytest.raises(GitGoError):
-        undo_commit()
-    mock_run_command.assert_called_once()
-
-
-@patch("pygitgo.commands.undo.run_command")
-@patch("pygitgo.commands.undo.success")
-def test_undo_add_success(mock_success, mock_run_command):
-    undo_add()
-    mock_run_command.assert_called_once_with(["git", "reset", "HEAD"])
-    mock_success.assert_called_once()
-
-
-@patch("pygitgo.commands.undo.run_command")
-def test_undo_add_failure(mock_run_command):
-    mock_run_command.side_effect = GitCommandError(["git", "reset", "HEAD"])
-    with pytest.raises(GitCommandError):
-        undo_add()
-    mock_run_command.assert_called_once()
-
-
-@patch("pygitgo.commands.undo.run_command")
-@patch("pygitgo.commands.undo.success")
-@patch("pygitgo.commands.undo.input", return_value="y")
-def test_undo_changes_success(mock_input, mock_success, mock_run_command):
-    undo_changes()
-    mock_input.assert_called_once()
-    assert mock_run_command.call_count == 2
-    mock_run_command.assert_any_call(["git", "reset", "--hard", "HEAD"], loading_msg="Throwing away edits...")
-    mock_run_command.assert_any_call(["git", "clean", "-fd"], loading_msg="Removing new files...")
-    mock_success.assert_called_once()
-
-
-@patch("pygitgo.commands.undo.run_command")
-@patch("pygitgo.commands.undo.info")
-@patch("pygitgo.commands.undo.input", return_value="n")
-def test_undo_changes_abort(mock_input, mock_info, mock_run_command):
-    undo_changes()
-    mock_input.assert_called_once()
-    mock_info.assert_called_once()
-    mock_run_command.assert_not_called()
-
-
-@patch("pygitgo.commands.undo.undo_commit")
-def test_undo_operation_commit(mock_undo_commit):
-    args = Namespace(action="commit")
-    undo_operation(args)
-    mock_undo_commit.assert_called_once()
-
-
-@patch("pygitgo.commands.undo.undo_add")
-def test_undo_operation_add(mock_undo_add):
-    args = Namespace(action="add")
-    undo_operation(args)
-    mock_undo_add.assert_called_once()
-
-
-@patch("pygitgo.commands.undo.undo_changes")
-def test_undo_operation_changes(mock_undo_changes):
-    args = Namespace(action="changes")
-    undo_operation(args)
-    mock_undo_changes.assert_called_once()
-
-
-def test_undo_operation_invalid():
-    args = Namespace(action="invalid")
-    with pytest.raises(GitGoError):
-        undo_operation(args)