pygitgo 1.2.1__tar.gz → 1.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygitgo
-Version: 1.2.1
+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.1 → 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.1 → pygitgo-1.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pygitgo"
-version = "1.2.1"
+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.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.1 → pygitgo-1.3.0}/src/pygitgo/main.py

@@ -7,6 +7,7 @@ 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
@@ -185,6 +186,7 @@ def get_version():
     except Exception:
         return "dev"
 
+
 def main():
     parser = argparse.ArgumentParser(
         prog='gitgo',
@@ -264,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:
@@ -289,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.1 → pygitgo-1.3.0/src/pygitgo.egg-info}/PKG-INFO

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

@@ -18,6 +18,7 @@ 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
@@ -31,4 +32,5 @@ 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_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)