pygitgo 1.2.0__tar.gz → 1.3.0__tar.gz

{pygitgo-1.2.0/src/pygitgo.egg-info → pygitgo-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygitgo
-Version: 1.2.0
+Version: 1.3.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
@@ -200,6 +209,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.0 → pygitgo-1.3.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
@@ -177,6 +186,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.0 → pygitgo-1.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pygitgo"
-version = "1.2.0"
+version = "1.3.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.2.0 → pygitgo-1.3.0}/src/pygitgo/auth/ssh_utils.py

@@ -1,5 +1,5 @@
-from pygitgo.utils.executor import run_command
 from pygitgo.utils.colors import info, success, warning, error
+from pygitgo.utils.executor import run_command
 from pygitgo.utils import platform_utils
 from pathlib import Path
 import subprocess
@@ -35,11 +35,15 @@ def ensure_github_known_host():
 def check_connection():
     ensure_github_known_host()
     result = run_command(["ssh", "-T", "git@github.com"], allow_fail=True, return_complete=True)
+    if not hasattr(result, "stderr") or not result.stderr:
+        return False
     return "successfully authenticated" in result.stderr
 
 def get_github_username():
 
     result = run_command(["ssh", "-T", "git@github.com"], allow_fail=True, return_complete=True)
+    if not hasattr(result, "stderr") or not result.stderr:
+        return None
     output = result.stderr
     
     if "Hi " in output and "!" in output:

{pygitgo-1.2.0 → pygitgo-1.3.0}/src/pygitgo/commands/git_operations.py

@@ -2,11 +2,18 @@ from pygitgo.auth.ssh_utils import convert_https_to_ssh, is_ssh_url, check_conne
 from pygitgo.utils.colors import info, success, warning, error
 from pygitgo.utils.executor import run_command
 from pygitgo.utils.config import get_config
+from argparse import Namespace
 import subprocess
 import sys
 import os
 
 
+def get_status_content():
+    status = run_command(["git", "status", "--porcelain"], allow_fail=True)
+    if isinstance(status, subprocess.CalledProcessError) or not status.strip():
+        sys.exit(1)
+    return status
+
 def get_current_branch():
     branch = run_command(["git", "branch", "--show-current"]).strip()
     if not branch:
@@ -26,8 +33,17 @@ def is_branch_exist(branch):
 
 
 def git_new_branch(branch):
-    run_command(["git", "checkout", "-b", branch], loading_msg=f"Creating branch '{branch}'...")
-    success(f"\nBranch '{branch}' created.\n")
+    result = run_command(["git", "checkout", "-b", branch], loading_msg=f"Creating branch '{branch}'...")
+    if isinstance(result, subprocess.CalledProcessError):
+        error(f"Failed to create branch '{branch}'! It may already exist.")
+        choice = input("\nWould you like to jump to the existing branch instead? (y/n): ").strip().lower()
+        if choice == "y":
+            from pygitgo.commands.jump import jump_operation
+            jump_operation(Namespace(branch=branch))
+        else:
+            sys.exit(1)
+    else:
+        success(f"\nBranch '{branch}' created.\n")
 
     return branch
 
@@ -136,8 +152,16 @@ def git_push(branch):
             if ssh_url:
                 run_command(["git", "remote", "set-url", "origin", ssh_url], loading_msg="Converting remote from HTTPS to SSH for secure push...")
                 success(f"Remote updated to: {ssh_url}")
-    
-    run_command(["git", "push", "-u", "origin", branch], loading_msg=f"Pushing to remote branch '{branch}'...")
+
+    try:    
+        run_command(["git", "push", "-u", "origin", branch], loading_msg=f"Pushing to remote branch '{branch}'...")
+    except (subprocess.CalledProcessError, OSError) as e:
+        error("Failed to push to remote repository!")
+        warning("Please check your network connection, remote URL, and authentication.")
+        if "rebase in progress" in str(e):
+            handle_rebase()
+        else:
+            sys.exit(1)
 
 
 def handle_rebase():

{pygitgo-1.2.0 → pygitgo-1.3.0}/src/pygitgo/commands/jump.py

@@ -1,9 +1,8 @@
 from pygitgo.commands.git_operations import (
     is_branch_exist, get_current_branch, git_new_branch, get_main_branch
 )
-from pygitgo.utils.executor import run_command
-from pygitgo.commands.state import *
 from pygitgo.utils.colors import warning, info, success, error
+from pygitgo.utils.executor import run_command
 import subprocess
 import sys
 

{pygitgo-1.2.0 → pygitgo-1.3.0}/src/pygitgo/commands/state.py

@@ -1,5 +1,5 @@
-from pygitgo.utils.executor import run_command
 from pygitgo.utils.colors import info, highlight, error, warning, success
+from pygitgo.utils.executor import run_command
 import sys
 
 
@@ -59,20 +59,19 @@ def display_save_states():
 
 
 def is_number(value):
-    try:
-        float(value)
-        return True
-    except ValueError:
-        return False
+    val = str(value).strip()
+    if val.startswith('-'):
+        return val[1:].isdigit()
+    return val.isdigit()
     
 def validate_state_id(state_id, save_states):
     if not is_number(state_id):
         error("\nInvalid input. Please enter a valid state ID.\n")
         return False
-    elif (int(float(state_id)) - 1) < 0:
+    elif (int(state_id) - 1) < 0:
         error("\nState ID cannot be '0' or negative. Please enter a valid state ID.\n")
         return False
-    elif (int(float(state_id)) - 1) >= len(save_states):
+    elif (int(state_id) - 1) >= len(save_states):
         error("\nState ID out of range. Please enter a valid state ID.\n")
         return False
     return True
@@ -124,9 +123,13 @@ def save_state(state_name=None):
     if not state_name:
         state_name = "Auto-Save"
 
-    run_command(["git", "stash", "push", "-m", state_name])
-
-    success(f"\nState '{state_name}' saved successfully.\n")
+    output = run_command(["git", "stash", "push", "-m", state_name], allow_fail=True)
+    if isinstance(output, Exception):
+        error(f"\nFailed to save state '{state_name}'.\n")
+    elif "No local changes to save" in output:
+        warning("\nNo local changes to save.\n")
+    else:
+        success(f"\nState '{state_name}' saved successfully.\n")
 
 
 def delete_state(identifier=None):

pygitgo-1.3.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.0 → pygitgo-1.3.0}/src/pygitgo/main.py

@@ -1,18 +1,18 @@
-from pygitgo.auth.ssh_utils import ensure_github_known_host
 from pygitgo.commands.git_operations import (
     git_new_branch, git_commit, git_init, add_remote_origin,
-    confirm_remote_link, create_main_branch, check_and_sync_branch,
-    git_push, handle_rebase, get_current_branch, is_branch_exist
+    confirm_remote_link, git_push, get_current_branch, is_branch_exist
 )
-from pygitgo.utils.colors import info, success, warning, error, highlight
+from pygitgo.utils.colors import info, success, warning, error
 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.jump import jump_operation
 from pygitgo.utils.executor import run_command
 from pygitgo.auth.manager import login, logout
 from pygitgo.auth.account import get_user
-from pygitgo.exceptions import GitGoError
+from argparse import Namespace
 import subprocess
 import argparse
 import sys
@@ -109,11 +109,24 @@ def push_operation(args):
         if branch and not message and not is_branch_exist(branch):
             message = branch
             branch = get_current_branch()
+            info(f"No branch name provided. Using current branch: '{branch}'\n")
+            
+        elif branch and is_branch_exist(branch):
+            current_branch = get_current_branch()
+            if current_branch != branch:
+                warning(f"You are currently on branch '{current_branch}', not '{branch}'.")
+                user_choice = input(f"Do you want to switch to branch '{branch}'? (y/n): ").lower()
+                if user_choice != 'y':
+                    error("\nPush aborted to prevent committing to the wrong branch.\n")
+                    sys.exit(1)
+                jump_operation(Namespace(branch=branch))
+    
         elif not branch:
             branch = get_current_branch()
 
     if not message:
         message = get_config("default-message", "New Project Update")
+        info(f"No commit message provided. Using default: '{message}'\n")
 
     commit_made = git_commit(message)
     
@@ -129,7 +142,7 @@ def push_operation(args):
                 info("\nWorking tree is clean and everything is up to date.")
                 warning("Make some changes first before using GitGo to commit and push.")
                 return
-        except:
+        except (GitCommandError, Exception):
             warning("\nNo changes to commit. Cannot verify remote status.")
             warning("Make some changes first or check your git remote configuration.")
             return
@@ -173,6 +186,7 @@ def get_version():
     except Exception:
         return "dev"
 
+
 def main():
     parser = argparse.ArgumentParser(
         prog='gitgo',
@@ -252,6 +266,22 @@ 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'"
+    )
+
     args = parser.parse_args()
 
     if args.ready:
@@ -277,6 +307,8 @@ def main():
             user_management(args)
         elif args.command == "config":
             config_operation(args)
+        elif args.command == "undo":
+            undo_operations(args)
     except GitGoError as e:
         error(f"\n{e}\n")
         sys.exit(1)

{pygitgo-1.2.0 → pygitgo-1.3.0}/src/pygitgo/utils/config.py

@@ -51,4 +51,6 @@ def config_operation(args):
         if current_value:
             info(f"\n{key} is currently set to: '{current_value}'\n")
         else:
-            warning(f"\n{key} is not currently set.\n")
+            warning(f"\n{key} is not currently set.\n")
+
+            

{pygitgo-1.2.0 → pygitgo-1.3.0}/src/pygitgo/utils/executor.py

@@ -1,8 +1,8 @@
-import subprocess
-import sys
-import os
 from pygitgo.utils.colors import error, info, success, warning
 from pygitgo.exceptions import GitCommandError
+from yaspin import yaspin
+import subprocess
+import os
 
 
 def run_command(command, allow_fail=False, return_complete=False, loading_msg=None):
@@ -15,7 +15,6 @@ def run_command(command, allow_fail=False, return_complete=False, loading_msg=No
     :param loading_msg: if provided, show a yaspin spinner with this message
     :raises GitCommandError: when the command fails and allow_fail is False
     """
-    from yaspin import yaspin
 
     spinner = yaspin(text=loading_msg, color="cyan") if loading_msg else None
 
@@ -34,11 +33,18 @@ def run_command(command, allow_fail=False, return_complete=False, loading_msg=No
             spinner.ok("✔")
 
         return result if return_complete else result.stdout.strip()
-    except subprocess.CalledProcessError as e:
+    except (subprocess.CalledProcessError, OSError) as e:
         if spinner:
             spinner.fail("✖")
 
-        stderr = e.stderr.strip() if e.stderr else ""
+        stderr = ""
+        returncode = 1
+
+        if isinstance(e, subprocess.CalledProcessError):
+            stderr = e.stderr.strip() if e.stderr else ""
+            returncode = e.returncode
+        else:
+            stderr = f"Command not found or execution failed: {str(e)}"
         
         if "detected dubious ownership" in stderr:
             error(f"\nSECURITY ALERT: {stderr}")
@@ -68,4 +74,4 @@ def run_command(command, allow_fail=False, return_complete=False, loading_msg=No
         if allow_fail:
             return e
         
-        raise GitCommandError(command, stderr=stderr, returncode=e.returncode)
+        raise GitCommandError(command, stderr=stderr, returncode=returncode)

{pygitgo-1.2.0 → pygitgo-1.3.0}/src/pygitgo/utils/setup.py

@@ -19,7 +19,7 @@ def ensure_first_run_setup():
 
     is_initialized = get_config("initialized", fallback_value="false")
 
-    if not is_initialized:
+    if is_initialized == "false":
         info("\nInitializing GitGo network settings for the first time... please wait.")
         ensure_github_known_host()
 

{pygitgo-1.2.0 → pygitgo-1.3.0/src/pygitgo.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygitgo
-Version: 1.2.0
+Version: 1.3.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
@@ -200,6 +209,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.0 → pygitgo-1.3.0}/src/pygitgo.egg-info/SOURCES.txt

@@ -18,15 +18,19 @@ src/pygitgo/commands/__init__.py
 src/pygitgo/commands/git_operations.py
 src/pygitgo/commands/jump.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
 src/pygitgo/utils/executor.py
 src/pygitgo/utils/platform_utils.py
 src/pygitgo/utils/setup.py
+tests/test_config.py
 tests/test_git_operations.py
 tests/test_jump.py
 tests/test_main.py
 tests/test_platform.py
+tests/test_setup.py
 tests/test_state.py
+tests/test_undo.py
 tests/test_url_validator.py

pygitgo-1.3.0/tests/test_config.py

@@ -0,0 +1,99 @@
+from pygitgo.utils.config import get_config, set_config, config_operation
+from conftest import capture_system_exit_code
+from argparse import Namespace
+import subprocess
+
+
+def test_get_config_fallback(mocker):
+    fake_run = mocker.patch('pygitgo.utils.config.run_command', return_value="")
+
+    fallback_value = "false"
+
+    result = get_config("default-key", fallback_value)
+    assert result == fallback_value
+
+def test_get_config_ok(mocker):
+    fake_run = mocker.patch('pygitgo.utils.config.run_command', return_value="true")
+
+    fallback_value = "false"
+
+    result = get_config("default-key", fallback_value)
+    assert result != fallback_value
+
+def test_set_config_fallback(mocker):
+    fake_run = mocker.patch('pygitgo.utils.config.run_command', return_value=subprocess.CalledProcessError(1, 'git'))
+    fake_error = mocker.patch('pygitgo.utils.config.error')
+
+    key = 'default-key'
+
+    result = set_config(key, 'true')
+    assert result == False
+
+    fake_error.assert_called_with(f"\nFailed to save configuration for '{key}'.")
+
+def test_set_config_ok(mocker):
+    fake_run = mocker.patch('pygitgo.utils.config.run_command', return_value='ok')
+    fake_error = mocker.patch('pygitgo.utils.config.error')
+    fake_success = mocker.patch('pygitgo.utils.config.success')
+    
+    key = 'default-key'
+    value = 'true'
+
+    result = set_config(key, value)
+    assert result == True
+
+    fake_error.assert_not_called()
+    fake_success.assert_called_with(f"\nConfiguration saved: {key} = '{value}'")
+
+def test_config_operation_not_valid_keys(mocker):
+    fake_error = mocker.patch('pygitgo.utils.config.error')
+    fake_warning = mocker.patch('pygitgo.utils.config.warning')
+    
+
+    VALID_KEYS = ["default-branch", "default-message"]
+
+    key = "not-valid"
+    value = "true"
+    args = Namespace(key=key, action="set", value=value)
+
+    assert capture_system_exit_code(lambda: config_operation(args)) is None
+
+    fake_error.assert_called_with(f"\nInvalid configuration key: '{key}'")
+    fake_warning.assert_called_with(f"Valid keys are: {', '.join(VALID_KEYS)}\n")
+
+def test_get_config_strip(mocker):
+    fake_run = mocker.patch('pygitgo.utils.config.run_command', return_value="  true  \n")
+    result = get_config("default-key", "false")
+    assert result == "true"
+
+def test_get_config_error_handling(mocker):
+    fake_run = mocker.patch('pygitgo.utils.config.run_command', return_value=subprocess.CalledProcessError(1, 'git'))
+    result = get_config("default-key", "fallback")
+    assert result == "fallback"
+
+def test_config_operation_set_no_value(mocker):
+    fake_error = mocker.patch('pygitgo.utils.config.error')
+    args = Namespace(key="default-branch", action="set") # value is missing
+    config_operation(args)
+    fake_error.assert_called_with("\nYou must provide a value to set!\n")
+
+def test_config_operation_set_ok(mocker):
+    fake_set = mocker.patch('pygitgo.utils.config.set_config')
+    args = Namespace(key="default-branch", action="set", value="main")
+    config_operation(args)
+    fake_set.assert_called_with("default-branch", "main")
+
+def test_config_operation_get_ok(mocker):
+    mocker.patch('pygitgo.utils.config.get_config', return_value="main")
+    fake_info = mocker.patch('pygitgo.utils.config.info')
+    args = Namespace(key="default-branch", action="get")
+    config_operation(args)
+    fake_info.assert_called_with("\ndefault-branch is currently set to: 'main'\n")
+
+def test_config_operation_get_none(mocker):
+    mocker.patch('pygitgo.utils.config.get_config', return_value=None)
+    fake_warning = mocker.patch('pygitgo.utils.config.warning')
+    args = Namespace(key="default-branch", action="get")
+    config_operation(args)
+    fake_warning.assert_called_with("\ndefault-branch is not currently set.\n")
+

{pygitgo-1.2.0 → pygitgo-1.3.0}/tests/test_git_operations.py

@@ -7,7 +7,7 @@ from pygitgo.commands.git_operations import (
 from unittest.mock import call
 import subprocess
 import pytest
-import os
+
 
 def test_git_branch_logic(mocker):
     fake_run = mocker.patch("pygitgo.commands.git_operations.run_command")
@@ -21,6 +21,36 @@ def test_git_branch_logic(mocker):
         loading_msg="Creating branch 'hello-world'..."
     )
 
+def test_git_branch_exists_jump_yes(mocker):
+    fake_run = mocker.patch("pygitgo.commands.git_operations.run_command", return_value=subprocess.CalledProcessError(1, 'git'))
+    mocker.patch("builtins.input", return_value="y")
+    fake_jump = mocker.patch("pygitgo.commands.jump.jump_operation")
+    fake_error = mocker.patch("pygitgo.commands.git_operations.error")
+
+    branch_name = "existing-branch"
+    result = git_new_branch(branch_name)
+    
+    assert result == "existing-branch"
+    fake_error.assert_called_once_with(f"Failed to create branch '{branch_name}'! It may already exist.")
+    
+    args = fake_jump.call_args[0][0]
+    assert args.branch == branch_name
+
+def test_git_branch_exists_jump_no(mocker):
+    fake_run = mocker.patch("pygitgo.commands.git_operations.run_command", return_value=subprocess.CalledProcessError(1, 'git'))
+    mocker.patch("builtins.input", return_value="n")
+    fake_jump = mocker.patch("pygitgo.commands.jump.jump_operation")
+    fake_error = mocker.patch("pygitgo.commands.git_operations.error")
+
+    branch_name = "existing-branch"
+    
+    with pytest.raises(SystemExit) as exc_info:
+        git_new_branch(branch_name)
+    
+    assert exc_info.value.code == 1
+    fake_error.assert_called_once_with(f"Failed to create branch '{branch_name}'! It may already exist.")
+    fake_jump.assert_not_called()
+
 def test_git_commit(mocker):
     fake_run = mocker.patch("pygitgo.commands.git_operations.run_command")\
     

{pygitgo-1.2.0 → pygitgo-1.3.0}/tests/test_jump.py

@@ -1,18 +1,13 @@
 from pygitgo.commands.jump import undo_jump_operation, jump_operation
+from conftest import capture_system_exit_code
 from argparse import Namespace
 import subprocess
 import pytest
 
+
 def make_args(branch):
-    """Helper to create an argparse-like Namespace for jump_operation."""
     return Namespace(branch=branch)
 
-def check_pytest_system_exit(function):
-    with pytest.raises(SystemExit) as exc_info:
-        function()
-
-    return exc_info.value.code
-
 def test_undo_jump_operation_no_stash(mocker):
     fake_run = mocker.patch('pygitgo.commands.jump.run_command', return_value="")
     
@@ -47,7 +42,7 @@ def test_jump_operation_same_branch(mocker):
     )
     fake_warning = mocker.patch('pygitgo.commands.jump.warning')
 
-    assert check_pytest_system_exit(lambda: jump_operation(make_args(main_branch))) == 0
+    assert capture_system_exit_code(lambda: jump_operation(make_args(main_branch))) == 0
 
     fake_warning.assert_called_with(f"\nYou are already on branch '{main_branch}'.\n")
 
@@ -60,7 +55,7 @@ def test_jump_operation_not_valid_repo(mocker):
         return_value=subprocess.CalledProcessError(1, 'git')
     )
     
-    assert check_pytest_system_exit(lambda: jump_operation(make_args('main'))) == 1
+    assert capture_system_exit_code(lambda: jump_operation(make_args('main'))) == 1
 
     fake_warning.assert_called_with("\nUnable to check for uncommitted changes. Please ensure you're in a valid git repository.")
 
@@ -77,7 +72,7 @@ def test_jump_operation_has_changes_exit(mocker):
         side_effect=['some-changes']
     )
 
-    assert check_pytest_system_exit(lambda: jump_operation(make_args('main'))) == 0
+    assert capture_system_exit_code(lambda: jump_operation(make_args('main'))) == 0
 
     fake_warning.assert_any_call("\nYou cannot switch branches with unsaved changes. Jump canceled.\n")
     fake_run.assert_any_call(['git', 'status', '--porcelain'], allow_fail=True, loading_msg="Checking for uncommitted changes...")
@@ -94,7 +89,7 @@ def test_jump_operation_save_changes_error(mocker):
         )
     )
 
-    assert check_pytest_system_exit(lambda: jump_operation(make_args('main'))) == 1
+    assert capture_system_exit_code(lambda: jump_operation(make_args('main'))) == 1
 
     fake_warning.assert_called_with("\nFailed to save your changes. Please resolve any issues and try again.")
     fake_run.assert_any_call(['git', 'status', '--porcelain'], allow_fail=True, loading_msg="Checking for uncommitted changes...")
@@ -115,7 +110,7 @@ def test_jump_operation_no_changes(mocker):
 
     target_branch = 'feature'
     
-    assert check_pytest_system_exit(lambda: jump_operation(make_args(target_branch))) == 0
+    assert capture_system_exit_code(lambda: jump_operation(make_args(target_branch))) == 0
 
     fake_success.assert_called_with(f"\nSuccess! You are now on '{target_branch}'.\n")
     fake_run.assert_any_call(['git', 'status', '--porcelain'], allow_fail=True, loading_msg="Checking for uncommitted changes...")
@@ -143,7 +138,7 @@ def test_jump_operation_branch_not_exist_cancel_operation(mocker):
 
     target_branch = 'feature'
     
-    assert check_pytest_system_exit(lambda: jump_operation(make_args(target_branch))) == 0
+    assert capture_system_exit_code(lambda: jump_operation(make_args(target_branch))) == 0
 
     fake_info.assert_any_call('\nYour changes have been saved. Jumping to the new branch...')
     fake_info.assert_any_call("Exiting without jumping...\n")
@@ -175,7 +170,7 @@ def test_jump_operation_branch_not_exist_create_branch(mocker):
 
     target_branch = 'feature'
     
-    assert check_pytest_system_exit(lambda: jump_operation(make_args(target_branch))) == 0
+    assert capture_system_exit_code(lambda: jump_operation(make_args(target_branch))) == 0
 
     fake_info.assert_called_with('\nYour changes have been saved. Jumping to the new branch...')
     fake_success.assert_any_call(f"\nSuccess! You are now on '{target_branch}'.")
@@ -204,7 +199,7 @@ def test_jump_operation_sync_fail_cancel(mocker):
         )
     )
 
-    assert check_pytest_system_exit(lambda: jump_operation(make_args('feature'))) == 1
+    assert capture_system_exit_code(lambda: jump_operation(make_args('feature'))) == 1
 
     fake_warning.assert_any_call("\nFailed to pull updates from 'main'. Make sure you have internet or the remote branch exists.")
 
@@ -225,7 +220,7 @@ def test_jump_operation_sync_fail_stay(mocker):
         )
     )
 
-    assert check_pytest_system_exit(lambda: jump_operation(make_args('feature'))) == 0
+    assert capture_system_exit_code(lambda: jump_operation(make_args('feature'))) == 0
 
     fake_success.assert_any_call("\nOkay! You are on the new branch, but without the latest updates from 'main'.")
 
@@ -247,7 +242,7 @@ def test_jump_operation_merge_conflict_cancel(mocker):
         )
     )
 
-    assert check_pytest_system_exit(lambda: jump_operation(make_args('feature'))) == 0
+    assert capture_system_exit_code(lambda: jump_operation(make_args('feature'))) == 0
 
     fake_error.assert_any_call("\nSTOP! There is a 'Merge Conflict'.")
 
@@ -270,7 +265,7 @@ def test_jump_operation_merge_conflict_stay(mocker):
         )
     )
 
-    assert check_pytest_system_exit(lambda: jump_operation(make_args('feature'))) == 0
+    assert capture_system_exit_code(lambda: jump_operation(make_args('feature'))) == 0
 
     fake_success.assert_any_call("\nOkay! You are on the new branch with your code.")
     fake_warning.assert_any_call("Please open your code editor RIGHT NOW to fix the conflicts!")

{pygitgo-1.2.0 → pygitgo-1.3.0}/tests/test_main.py

@@ -1,5 +1,6 @@
-import pytest
 from pygitgo.main import validate_repo_url
+import pytest
+
 
 @pytest.mark.parametrize("url", [
     "https://github.com/Huerte/GitGo.git",

pygitgo-1.3.0/tests/test_setup.py

@@ -0,0 +1,55 @@
+from pygitgo.utils.setup import check_git_installed, ensure_first_run_setup
+from conftest import capture_system_exit_code
+
+
+def test_check_git_installed_no_exist(mocker):
+    mocker.patch("shutil.which", return_value=None)
+    fake_error = mocker.patch("pygitgo.utils.setup.error")
+    fake_info = mocker.patch("pygitgo.utils.setup.info")
+
+    assert capture_system_exit_code(lambda: check_git_installed()) == 1
+
+    fake_error.assert_called_with("\nGit is not installed or not found on your PATH!")
+    fake_info.assert_any_call("Install Git from: https://git-scm.com/downloads")
+    fake_info.assert_any_call("After installing, restart your terminal and try again.\n")
+
+def test_check_git_installed_exist(mocker):
+    mocker.patch("shutil.which", return_value="ok")
+    fake_error = mocker.patch("pygitgo.utils.setup.error")
+    fake_info = mocker.patch("pygitgo.utils.setup.info")
+
+    assert capture_system_exit_code(lambda: check_git_installed()) == None
+
+    fake_error.assert_not_called()
+    fake_info.assert_not_called()
+
+def test_ensure_first_run_setup_already_initialized(mocker):
+    mocker.patch('pygitgo.utils.setup.check_git_installed', return_value=None)
+    fake_get_config = mocker.patch('pygitgo.utils.setup.get_config', return_value="ok")
+    fake_github_function = mocker.patch('pygitgo.utils.setup.ensure_github_known_host', return_value=None)
+    fake_set_config = mocker.patch('pygitgo.utils.setup.set_config', return_value=True)
+    fake_info = mocker.patch("pygitgo.utils.setup.info")
+
+    ensure_first_run_setup()
+
+    fake_info.assert_not_called()
+    fake_github_function.assert_not_called()
+    fake_set_config.assert_not_called()
+
+    fake_get_config.assert_called_with("initialized", fallback_value="false")
+
+def test_ensure_first_run_setup_not_initialized(mocker):
+    mocker.patch('pygitgo.utils.setup.check_git_installed', return_value=None)
+    fake_get_config = mocker.patch('pygitgo.utils.setup.get_config', return_value="false")
+    fake_github_function = mocker.patch('pygitgo.utils.setup.ensure_github_known_host', return_value=None)
+    fake_set_config = mocker.patch('pygitgo.utils.setup.set_config', return_value=True)
+    fake_info = mocker.patch("pygitgo.utils.setup.info")
+
+    ensure_first_run_setup()
+
+    fake_info.assert_called_with("\nInitializing GitGo network settings for the first time... please wait.")
+    fake_github_function.assert_called_once()
+    fake_set_config.assert_called_with("initialized", "true")
+
+    fake_get_config.assert_called_with("initialized", fallback_value="false")
+

{pygitgo-1.2.0 → pygitgo-1.3.0}/tests/test_state.py

@@ -3,12 +3,11 @@ from pygitgo.commands.state import (
     all_save_state
 )
 from unittest.mock import call
-import subprocess
 import pytest
-import os
+
 
 @pytest.mark.parametrize('state_id',[
-    '1', '3', '11', '00002', '7.0'
+    '1', '3', '11', '00002'
 ])
 def test_validate_state_id(state_id, mocker):
     fake_error = mocker.patch('pygitgo.commands.state.error')
@@ -20,7 +19,7 @@ def test_validate_state_id(state_id, mocker):
     fake_error.assert_not_called()
 
 @pytest.mark.parametrize('state_id',[
-    '-1', '-3', '-11', '-00002', '-7.0'
+    '-1', '-3', '-11', '-00002'
 ])
 def test_validate_state_id_negative(state_id, mocker):
 
@@ -33,7 +32,7 @@ def test_validate_state_id_negative(state_id, mocker):
     fake_error.assert_called_with("\nState ID cannot be '0' or negative. Please enter a valid state ID.\n")
 
 @pytest.mark.parametrize('state_id',[
-    '4', '10', '15', '0000020', '00007.00000'
+    '4', '10', '15', '0000020'
 ])
 def test_validate_state_id_out_scope(state_id, mocker):
 
@@ -156,21 +155,21 @@ def test_load_state_no_args(mocker):
 
 
 def test_save_state_no_args(mocker):
-    fake_run = mocker.patch("pygitgo.commands.state.run_command")
+    fake_run = mocker.patch("pygitgo.commands.state.run_command", return_value="Saved working directory")
     fake_success = mocker.patch("pygitgo.commands.state.success")
 
     save_state()
 
-    fake_run.assert_called_once_with(["git", "stash", "push", "-m", "Auto-Save"])
+    fake_run.assert_called_once_with(["git", "stash", "push", "-m", "Auto-Save"], allow_fail=True)
     fake_success.assert_called_once_with("\nState 'Auto-Save' saved successfully.\n")
 
 def test_save_state_with_name(mocker):
-    fake_run = mocker.patch("pygitgo.commands.state.run_command")
+    fake_run = mocker.patch("pygitgo.commands.state.run_command", return_value="Saved working directory")
     fake_success = mocker.patch("pygitgo.commands.state.success")
 
     save_state("My-State")
 
-    fake_run.assert_called_once_with(["git", "stash", "push", "-m", "My-State"])
+    fake_run.assert_called_once_with(["git", "stash", "push", "-m", "My-State"], allow_fail=True)
     fake_success.assert_called_once_with("\nState 'My-State' saved successfully.\n")
 
 

pygitgo-1.3.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)

{pygitgo-1.2.0 → pygitgo-1.3.0}/src/pygitgo/auth/account.py

@@ -1,5 +1,5 @@
-from pygitgo.utils.executor import run_command
 from pygitgo.utils.colors import info, success, warning, error, BLUE, RESET
+from pygitgo.utils.executor import run_command
 import subprocess
 
 

{pygitgo-1.2.0 → pygitgo-1.3.0}/src/pygitgo/auth/manager.py

@@ -1,5 +1,5 @@
-from pygitgo.utils.executor import run_command
 from pygitgo.utils.colors import info, success, warning, error
+from pygitgo.utils.executor import run_command
 from . import ssh_utils
 import os