pygitgo 1.2.1__tar.gz → 1.4.0__tar.gz

{pygitgo-1.2.1/src/pygitgo.egg-info → pygitgo-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygitgo
-Version: 1.2.1
+Version: 1.4.0
 Summary: GitGo CLI - Your Fast Git Companion. Simplifies git push, link, stash, and user management.
 Author: Huerte
 License: GPL-3.0-or-later
@@ -40,7 +40,7 @@ Dynamic: license-file
 
 ---
 
-GitGo wraps your most repetitive Git operations — init, add, commit, push, branch, stash — into short, memorable commands. It also handles the friction points most tools ignore: automatic SSH setup, HTTPS-to-SSH conversion, and a human-friendly stash interface called **state management**.
+GitGo wraps your most repetitive git commands into short ones you can actually remember. It covers init, add, commit, push, branch, and stash. It also handles the things most tools skip like automatic SSH setup, HTTPS to SSH conversion, and a simple stash interface called state management.
 
 ```bash
 # Instead of this:
@@ -76,6 +76,7 @@ gitgo link https://github.com/username/repo.git "init"
 GitGo provides a CLI environment designed for faster and simpler Git workflows. Built to be intuitive, fast, and frictionless.
 
 - **Simplified Git Operations:** Replaces chained commands with single intuitive commands for linking, pushing, and stashing.
+- **Easy Undo Operations:** Safely undo commits, un-queue files, or wipe local changes without any complex Git jargon.
 - **Smart Branch Hopping:** Safely traverse branches with `jump`. Auto-stashes messy code and prevents merge conflict disasters with a Try-And-Revert safety engine.
 - **State Management:** A human-readable interface over `git stash`. States are named and listed by index so you never have to remember cryptic stash references.
 - **Custom Defaults:** Save your preferred branch name and commit message locally so you never have to type them again.
@@ -147,7 +148,15 @@ Jump to a different branch without worrying about your uncommitted changes. GitG
 gitgo jump feature/new-login
 ```
 
-### 5. Save Your Work-in-Progress
+### 5. Safely Undo Mistakes
+Easily fix common mistakes without losing work or needing to search for Git commands.
+```bash
+gitgo undo commit    # Undo the last commit (files stay safe)
+gitgo undo add       # Un-queue files (undo git add)
+gitgo undo changes   # DANGER: permanently wipe all unsaved edits
+```
+
+### 6. Save Your Work-in-Progress
 ```bash
 gitgo state save "halfway through refactor"
 gitgo state list
@@ -184,6 +193,15 @@ gitgo push -n [branch] [message]   # create new branch first
 
 If there are no new changes but unpushed commits exist, GitGo detects this and pushes without creating an empty commit.
 
+### `gitgo pull`
+
+Safely downloads updates from the remote server. It automatically stashes your messy code, pulls the updates cleanly underneath using a rebase, and then instantly puts your code back exactly how it was. 
+
+```bash
+gitgo pull             # Safely pull updates for your current branch
+gitgo pull <branch>    # Safely pull updates from a specific branch
+```
+
 ### `gitgo link`
 
 Initializes a Git repository in the current directory, connects it to a remote, and pushes. Handles already-initialized repos gracefully and pulls unrelated histories.
@@ -200,6 +218,16 @@ Safely switches branches without losing uncommitted progress. Auto-stashes, jump
 gitgo jump <branch>
 ```
 
+### `gitgo undo`
+
+Safely undo recent actions and mistakes using simple, human-readable commands.
+
+```bash
+gitgo undo commit    # Undo your last commit without losing files
+gitgo undo add       # Un-queue files (remove them from being ready to commit)
+gitgo undo changes   # Permanently wipe all new files and local edits
+```
+
 ### `gitgo state`
 
 A human-readable interface over `git stash`.

{pygitgo-1.2.1 → pygitgo-1.4.0}/README.md

@@ -17,7 +17,7 @@
 
 ---
 
-GitGo wraps your most repetitive Git operations — init, add, commit, push, branch, stash — into short, memorable commands. It also handles the friction points most tools ignore: automatic SSH setup, HTTPS-to-SSH conversion, and a human-friendly stash interface called **state management**.
+GitGo wraps your most repetitive git commands into short ones you can actually remember. It covers init, add, commit, push, branch, and stash. It also handles the things most tools skip like automatic SSH setup, HTTPS to SSH conversion, and a simple stash interface called state management.
 
 ```bash
 # Instead of this:
@@ -53,6 +53,7 @@ gitgo link https://github.com/username/repo.git "init"
 GitGo provides a CLI environment designed for faster and simpler Git workflows. Built to be intuitive, fast, and frictionless.
 
 - **Simplified Git Operations:** Replaces chained commands with single intuitive commands for linking, pushing, and stashing.
+- **Easy Undo Operations:** Safely undo commits, un-queue files, or wipe local changes without any complex Git jargon.
 - **Smart Branch Hopping:** Safely traverse branches with `jump`. Auto-stashes messy code and prevents merge conflict disasters with a Try-And-Revert safety engine.
 - **State Management:** A human-readable interface over `git stash`. States are named and listed by index so you never have to remember cryptic stash references.
 - **Custom Defaults:** Save your preferred branch name and commit message locally so you never have to type them again.
@@ -124,7 +125,15 @@ Jump to a different branch without worrying about your uncommitted changes. GitG
 gitgo jump feature/new-login
 ```
 
-### 5. Save Your Work-in-Progress
+### 5. Safely Undo Mistakes
+Easily fix common mistakes without losing work or needing to search for Git commands.
+```bash
+gitgo undo commit    # Undo the last commit (files stay safe)
+gitgo undo add       # Un-queue files (undo git add)
+gitgo undo changes   # DANGER: permanently wipe all unsaved edits
+```
+
+### 6. Save Your Work-in-Progress
 ```bash
 gitgo state save "halfway through refactor"
 gitgo state list
@@ -161,6 +170,15 @@ gitgo push -n [branch] [message]   # create new branch first
 
 If there are no new changes but unpushed commits exist, GitGo detects this and pushes without creating an empty commit.
 
+### `gitgo pull`
+
+Safely downloads updates from the remote server. It automatically stashes your messy code, pulls the updates cleanly underneath using a rebase, and then instantly puts your code back exactly how it was. 
+
+```bash
+gitgo pull             # Safely pull updates for your current branch
+gitgo pull <branch>    # Safely pull updates from a specific branch
+```
+
 ### `gitgo link`
 
 Initializes a Git repository in the current directory, connects it to a remote, and pushes. Handles already-initialized repos gracefully and pulls unrelated histories.
@@ -177,6 +195,16 @@ Safely switches branches without losing uncommitted progress. Auto-stashes, jump
 gitgo jump <branch>
 ```
 
+### `gitgo undo`
+
+Safely undo recent actions and mistakes using simple, human-readable commands.
+
+```bash
+gitgo undo commit    # Undo your last commit without losing files
+gitgo undo add       # Un-queue files (remove them from being ready to commit)
+gitgo undo changes   # Permanently wipe all new files and local edits
+```
+
 ### `gitgo state`
 
 A human-readable interface over `git stash`.

{pygitgo-1.2.1 → pygitgo-1.4.0}/pyproject.toml

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

pygitgo-1.4.0/src/pygitgo/commands/pull.py

@@ -0,0 +1,43 @@
+from pygitgo.utils.colors import success, warning, error, info
+from pygitgo.utils.executor import run_command
+from pygitgo.exceptions import GitCommandError
+from pygitgo.commands.git_operations import get_current_branch
+import subprocess
+import sys
+
+def pull_operation(args):
+    branch = args.branch
+
+    if not branch:
+        branch = get_current_branch()
+        info(f"No branch provided. Pulling latest updates for '{branch}'...\n")
+
+    try:
+        remote_refs = run_command(["git", "ls-remote", "--heads", "origin", branch], allow_fail=True)
+        if isinstance(remote_refs, subprocess.CalledProcessError) or not remote_refs.strip():
+            error(f"\nFailed! The branch '{branch}' does not exist on the remote server.")
+            warning("You might need to push your local branch first.\n")
+            sys.exit(1)
+
+        run_command(
+            ["git", "pull", "--rebase", "--autostash", "origin", branch], 
+            loading_msg=f"Downloading latest updates for '{branch}' (auto-saving your code)..."
+        )
+        
+        success(f"\nSuccess! Your project is now up to date with '{branch}'.\n")
+
+    except GitCommandError as e:
+        error_msg = str(e).lower()
+        if "conflict" in error_msg or "rebase in progress" in error_msg:
+            error("\nMERGE CONFLICT DETECTED!")
+            warning("Your local code clashes with the new code downloaded from the server.\n")
+            info("1. Open your code editor down below.")
+            info("2. Fix the red conflict lines in your files.")
+            info("3. Save the files.")
+            info("4. Run this command to finish:  git rebase --continue\n")
+            sys.exit(1)
+        else:
+            error("\nFailed to pull updates from the server!")
+            error("Please check your internet connection and try again.")
+            error(f"Details: {e}\n")
+            sys.exit(1)

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

@@ -0,0 +1,53 @@
+from pygitgo.utils.colors import success, warning, error, info
+from pygitgo.exceptions import GitCommandError
+from pygitgo.utils.executor import run_command
+import sys
+
+
+def undo_commit():
+    try:
+        run_command(["git", "reset", "--soft", "HEAD~"])
+        success("\nSuccess! Your last commit is undone. Your files are safe.\n")
+    except GitCommandError as e:
+        error("\nFailed! You might not have any previous commits to undo yet.")
+        error(f"Details: {e}\n")
+        sys.exit(1)
+    
+
+def undo_add():
+    try:
+        run_command(["git", "reset", "HEAD"])
+        success("\nSuccess! Files are no longer ready to commit.\n")
+    except GitCommandError as e:
+        error(f"\n{e}\n")
+        sys.exit(1)
+
+
+def undo_changes():
+    warning("\nDANGER: This will permanently delete all your new edits and new files!")
+    confirm = input("Are you sure you want to throw away all changes? (y/n): ")
+    if confirm.lower() != "y":
+        info("\nCanceled. Your files are safe.\n")
+        return
+    try:
+        run_command(["git", "reset", "--hard", "HEAD"], loading_msg="Throwing away edits...")
+        run_command(["git", "clean", "-fd"], loading_msg="Removing new files...")
+        
+        success("\nSuccess! All changes are completely gone. You have a clean start.\n")
+    except GitCommandError as e:
+        error(f"\n{e}\n")
+        sys.exit(1)
+
+
+def undo_operations(args):
+    action = args.action
+
+    if action == "commit":
+        undo_commit()
+    elif action == "add":
+        undo_add()
+    elif action == "changes":
+        undo_changes()
+    else:
+        error(f"\nUnknown undo operation: {action}\n")
+        sys.exit(1)

{pygitgo-1.2.1 → pygitgo-1.4.0}/src/pygitgo/main.py

@@ -7,6 +7,8 @@ from pygitgo.utils.config import get_config, config_operation
 from pygitgo.exceptions import GitCommandError, GitGoError
 from pygitgo.utils.setup import ensure_first_run_setup
 from pygitgo.commands.state import state_operations
+from pygitgo.commands.undo import undo_operations
+from pygitgo.commands.pull import pull_operation
 from pygitgo.commands.jump import jump_operation
 from pygitgo.utils.executor import run_command
 from pygitgo.auth.manager import login, logout
@@ -185,6 +187,7 @@ def get_version():
     except Exception:
         return "dev"
 
+
 def main():
     parser = argparse.ArgumentParser(
         prog='gitgo',
@@ -264,6 +267,33 @@ def main():
     config_parser.add_argument("key", choices=["default-branch", "default-message"], help="The setting to change")
     config_parser.add_argument("value", nargs="?", help="The new value (required for 'set')")
 
+    undo_parser = subparsers.add_parser("undo", 
+        help="Safely undo mistakes", 
+        epilog=(
+            "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"
+        ), 
+        formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    undo_parser.add_argument(
+        "action", 
+        choices=["commit", "add", "changes"], 
+        help="What to undo: 'commit', 'add', or 'changes'"
+    )
+
+    pull_parser = subparsers.add_parser("pull", 
+        help="Safely pull the latest code without losing your changes",
+        epilog=(
+            "Examples:\n"
+            "  gitgo pull                Safely pull updates for your current branch\n"
+            "  gitgo pull main           Safely pull updates from the 'main' branch\n"
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    pull_parser.add_argument("branch", nargs="?", default=None, help="The branch to pull from (default is your current branch)")
+
     args = parser.parse_args()
 
     if args.ready:
@@ -289,6 +319,10 @@ def main():
             user_management(args)
         elif args.command == "config":
             config_operation(args)
+        elif args.command == "undo":
+            undo_operations(args)
+        elif args.command == "pull":
+            pull_operation(args)
     except GitGoError as e:
         error(f"\n{e}\n")
         sys.exit(1)

{pygitgo-1.2.1 → pygitgo-1.4.0/src/pygitgo.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygitgo
-Version: 1.2.1
+Version: 1.4.0
 Summary: GitGo CLI - Your Fast Git Companion. Simplifies git push, link, stash, and user management.
 Author: Huerte
 License: GPL-3.0-or-later
@@ -40,7 +40,7 @@ Dynamic: license-file
 
 ---
 
-GitGo wraps your most repetitive Git operations — init, add, commit, push, branch, stash — into short, memorable commands. It also handles the friction points most tools ignore: automatic SSH setup, HTTPS-to-SSH conversion, and a human-friendly stash interface called **state management**.
+GitGo wraps your most repetitive git commands into short ones you can actually remember. It covers init, add, commit, push, branch, and stash. It also handles the things most tools skip like automatic SSH setup, HTTPS to SSH conversion, and a simple stash interface called state management.
 
 ```bash
 # Instead of this:
@@ -76,6 +76,7 @@ gitgo link https://github.com/username/repo.git "init"
 GitGo provides a CLI environment designed for faster and simpler Git workflows. Built to be intuitive, fast, and frictionless.
 
 - **Simplified Git Operations:** Replaces chained commands with single intuitive commands for linking, pushing, and stashing.
+- **Easy Undo Operations:** Safely undo commits, un-queue files, or wipe local changes without any complex Git jargon.
 - **Smart Branch Hopping:** Safely traverse branches with `jump`. Auto-stashes messy code and prevents merge conflict disasters with a Try-And-Revert safety engine.
 - **State Management:** A human-readable interface over `git stash`. States are named and listed by index so you never have to remember cryptic stash references.
 - **Custom Defaults:** Save your preferred branch name and commit message locally so you never have to type them again.
@@ -147,7 +148,15 @@ Jump to a different branch without worrying about your uncommitted changes. GitG
 gitgo jump feature/new-login
 ```
 
-### 5. Save Your Work-in-Progress
+### 5. Safely Undo Mistakes
+Easily fix common mistakes without losing work or needing to search for Git commands.
+```bash
+gitgo undo commit    # Undo the last commit (files stay safe)
+gitgo undo add       # Un-queue files (undo git add)
+gitgo undo changes   # DANGER: permanently wipe all unsaved edits
+```
+
+### 6. Save Your Work-in-Progress
 ```bash
 gitgo state save "halfway through refactor"
 gitgo state list
@@ -184,6 +193,15 @@ gitgo push -n [branch] [message]   # create new branch first
 
 If there are no new changes but unpushed commits exist, GitGo detects this and pushes without creating an empty commit.
 
+### `gitgo pull`
+
+Safely downloads updates from the remote server. It automatically stashes your messy code, pulls the updates cleanly underneath using a rebase, and then instantly puts your code back exactly how it was. 
+
+```bash
+gitgo pull             # Safely pull updates for your current branch
+gitgo pull <branch>    # Safely pull updates from a specific branch
+```
+
 ### `gitgo link`
 
 Initializes a Git repository in the current directory, connects it to a remote, and pushes. Handles already-initialized repos gracefully and pulls unrelated histories.
@@ -200,6 +218,16 @@ Safely switches branches without losing uncommitted progress. Auto-stashes, jump
 gitgo jump <branch>
 ```
 
+### `gitgo undo`
+
+Safely undo recent actions and mistakes using simple, human-readable commands.
+
+```bash
+gitgo undo commit    # Undo your last commit without losing files
+gitgo undo add       # Un-queue files (remove them from being ready to commit)
+gitgo undo changes   # Permanently wipe all new files and local edits
+```
+
 ### `gitgo state`
 
 A human-readable interface over `git stash`.

{pygitgo-1.2.1 → pygitgo-1.4.0}/src/pygitgo.egg-info/SOURCES.txt

@@ -17,7 +17,9 @@ src/pygitgo/auth/ssh_utils.py
 src/pygitgo/commands/__init__.py
 src/pygitgo/commands/git_operations.py
 src/pygitgo/commands/jump.py
+src/pygitgo/commands/pull.py
 src/pygitgo/commands/state.py
+src/pygitgo/commands/undo.py
 src/pygitgo/utils/__init__.py
 src/pygitgo/utils/colors.py
 src/pygitgo/utils/config.py
@@ -29,6 +31,8 @@ tests/test_git_operations.py
 tests/test_jump.py
 tests/test_main.py
 tests/test_platform.py
+tests/test_pull.py
 tests/test_setup.py
 tests/test_state.py
+tests/test_undo.py
 tests/test_url_validator.py

pygitgo-1.4.0/tests/test_pull.py

@@ -0,0 +1,77 @@
+import pytest
+from unittest.mock import patch, MagicMock
+from pygitgo.commands.pull import pull_operation
+from pygitgo.exceptions import GitCommandError
+from argparse import Namespace
+import subprocess
+
+@patch("pygitgo.commands.pull.run_command")
+@patch("pygitgo.commands.pull.success")
+@patch("pygitgo.commands.pull.get_current_branch", return_value="main")
+def test_pull_operation_success_no_branch(mock_get_branch, mock_success, mock_run_command):
+    mock_run_command.side_effect = [
+        "1234567890abcdef",  
+        None                 
+    ]
+    
+    args = Namespace(branch=None)
+    pull_operation(args)
+    
+    assert mock_run_command.call_count == 2
+    mock_run_command.assert_any_call(["git", "ls-remote", "--heads", "origin", "main"], allow_fail=True)
+    mock_run_command.assert_any_call(
+        ["git", "pull", "--rebase", "--autostash", "origin", "main"], 
+        loading_msg="Downloading latest updates for 'main' (auto-saving your code)..."
+    )
+    mock_success.assert_called_once()
+
+@patch("pygitgo.commands.pull.run_command")
+@patch("pygitgo.commands.pull.success")
+def test_pull_operation_success_with_branch(mock_success, mock_run_command):
+    mock_run_command.side_effect = [
+        "1234567890abcdef",  
+        None                 
+    ]
+    
+    args = Namespace(branch="feature/test")
+    pull_operation(args)
+    
+    assert mock_run_command.call_count == 2
+    mock_run_command.assert_any_call(["git", "ls-remote", "--heads", "origin", "feature/test"], allow_fail=True)
+    mock_run_command.assert_any_call(
+        ["git", "pull", "--rebase", "--autostash", "origin", "feature/test"], 
+        loading_msg="Downloading latest updates for 'feature/test' (auto-saving your code)..."
+    )
+    mock_success.assert_called_once()
+
+@patch("pygitgo.commands.pull.sys.exit")
+@patch("pygitgo.commands.pull.error")
+@patch("pygitgo.commands.pull.run_command")
+def test_pull_operation_branch_not_found(mock_run_command, mock_error, mock_exit):
+    mock_run_command.return_value = subprocess.CalledProcessError(128, ["git", "ls-remote"])
+    
+    args = Namespace(branch="does-not-exist")
+    pull_operation(args)
+    
+    mock_exit.assert_called_once_with(1)
+    mock_error.assert_called()
+
+@patch("pygitgo.commands.pull.sys.exit")
+@patch("pygitgo.commands.pull.error")
+@patch("pygitgo.commands.pull.run_command")
+def test_pull_operation_merge_conflict(mock_run_command, mock_error, mock_exit):
+    conflict_err = GitCommandError(["git", "pull"], stderr="merge conflict in file.py")
+
+    def side_effect_fn(*args, **kwargs):
+        cmd = args[0]
+        if cmd[1] == "ls-remote":
+            return "1234567890abcdef"
+        raise conflict_err
+
+    mock_run_command.side_effect = side_effect_fn
+    
+    args = Namespace(branch="main")
+    pull_operation(args)
+    
+    mock_exit.assert_called_once_with(1)
+    mock_error.assert_any_call("\nMERGE CONFLICT DETECTED!")

pygitgo-1.4.0/tests/test_undo.py

@@ -0,0 +1,94 @@
+import pytest
+from unittest.mock import patch, MagicMock
+from pygitgo.commands.undo import undo_commit, undo_add, undo_changes, undo_operations
+from pygitgo.exceptions import 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.sys.exit")
+@patch("pygitgo.commands.undo.error")
+@patch("pygitgo.commands.undo.run_command")
+def test_undo_commit_failure(mock_run_command, mock_error, mock_exit):
+    mock_run_command.side_effect = GitCommandError(["git", "reset", "--soft", "HEAD~"])
+    undo_commit()
+    mock_run_command.assert_called_once()
+    assert mock_error.call_count == 2
+    mock_exit.assert_called_once_with(1)
+
+
+@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.sys.exit")
+@patch("pygitgo.commands.undo.error")
+@patch("pygitgo.commands.undo.run_command")
+def test_undo_add_failure(mock_run_command, mock_error, mock_exit):
+    mock_run_command.side_effect = GitCommandError(["git", "reset", "HEAD"])
+    undo_add()
+    mock_run_command.assert_called_once()
+    mock_error.assert_called_once()
+    mock_exit.assert_called_once_with(1)
+
+
+@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_operations_commit(mock_undo_commit):
+    args = Namespace(action="commit")
+    undo_operations(args)
+    mock_undo_commit.assert_called_once()
+
+
+@patch("pygitgo.commands.undo.undo_add")
+def test_undo_operations_add(mock_undo_add):
+    args = Namespace(action="add")
+    undo_operations(args)
+    mock_undo_add.assert_called_once()
+
+
+@patch("pygitgo.commands.undo.undo_changes")
+def test_undo_operations_changes(mock_undo_changes):
+    args = Namespace(action="changes")
+    undo_operations(args)
+    mock_undo_changes.assert_called_once()
+
+
+@patch("pygitgo.commands.undo.sys.exit")
+@patch("pygitgo.commands.undo.error")
+def test_undo_operations_invalid(mock_error, mock_exit):
+    args = Namespace(action="invalid")
+    undo_operations(args)
+    mock_error.assert_called_once()
+    mock_exit.assert_called_once_with(1)