pygitgo 1.0.0__py3-none-any.whl

pygitgo/auth/account.py

@@ -0,0 +1,61 @@
+from pygitgo.utils.executor import run_command
+from pygitgo.utils.colors import info, success, warning, error, BLUE, RESET
+import subprocess
+
+
+def get_user():
+    try:
+        name = run_command(["git", "config", "--global", "user.name"], allow_fail=True)
+        email = run_command(["git", "config", "--global", "user.email"], allow_fail=True)
+
+        if not name or isinstance(name, subprocess.CalledProcessError):
+            name = None
+        if not email or isinstance(email, subprocess.CalledProcessError):
+            email = None
+        return name, email
+    except:
+        return None, None
+    
+def set_user(name, email):
+    run_command(["git", "config", "--global", "user.name", name])
+    run_command(["git", "config", "--global", "user.email", email])
+    success(f"\nGit user configured Successfully")
+    print(f"{BLUE}Username{RESET} : {name}")
+    print(f"{BLUE}Email    {RESET}: {email}")
+
+def ensure_user_configure(default_email=None, default_username=None):
+
+    name, email = get_user()
+
+    if name and email:
+        return True
+    
+    if default_username and default_email:
+        info(f"\nConfiguring Git identity from GitHub...")
+        set_user(default_username, default_email)
+        return True
+    
+    warning("\nGit user identity is not configured!")
+    info("This is required for your commits to be attributed correctly.")
+    
+    if default_username:
+        new_username = default_username
+        info(f"Using GitHub username: {new_username}")
+    else:
+        new_username = input("Enter your Username (for commits): ").strip()
+    
+    prompt_email = "Enter your Email (for commits)"
+    if default_email:
+        prompt_email += f" [{default_email}]"
+    
+    new_email = input(f"{prompt_email}: ").strip()
+    
+    if not new_email and default_email:
+        new_email = default_email
+        
+    if new_username and new_email:
+        set_user(new_username, new_email)
+        return True
+    
+    error("Invalid configuration. Name and Email are required.")
+    return False

pygitgo/auth/manager.py

@@ -0,0 +1,78 @@
+from pygitgo.utils.executor import run_command
+from pygitgo.utils.colors import info, success, warning, error
+from . import ssh_utils
+import os
+
+def login():
+    if ssh_utils.check_connection():
+        success("You are already logged in!")
+        return True
+
+    info("initiating login sequence...")
+
+    while True:
+        email = input("Enter your email for GitHub: ").strip()
+        if "@" in email and "." in email:
+            break
+        else:
+            error("Please enter a valid email address.")
+        
+
+    key_path = ssh_utils.generate_ssh_key(email=email)
+    pub_key_path = str(key_path) + ".pub"
+
+    with open(pub_key_path, 'r') as f:
+        pub_key = f.read()
+
+    if pub_key:
+        success("SSH Key generated successfully!")
+
+        print("\n" + "=" * len(pub_key))
+        print(pub_key, end='')
+        print("=" * len(pub_key) + "\n")
+        
+        info("Copy the key above (between the lines).")
+
+        input(
+            "\nPress Enter to open your GitHub SSH key settings page in the browser...\n"
+            "Make sure you are logged in so you can add your new key. "
+            "After adding, return here to continue."
+        )
+        ssh_utils.open_github_settings()
+
+    else:
+        error("Failed to read the generated public key.")
+        return False
+    
+    input("\nPress Enter after adding the key to GitHub...")
+
+    if ssh_utils.check_connection():
+        from .account import ensure_user_configure
+        
+        github_username = ssh_utils.get_github_username()
+
+        ensure_user_configure(default_email=email, default_username=github_username)
+
+        success("\nLogin Successful! You are connected.\n")
+        return True
+    
+    error("Login Failed. Please try again.")
+    return False
+    
+def logout():
+    key_path = ssh_utils.get_ssh_key_path()
+    if not key_path.exists():
+        warning("You are already logged out (no keys found).")
+        return False
+    
+    try:
+        run_command(["git", "config", "--global", "--unset-all", "user.name"], allow_fail=True)
+        run_command(["git", "config", "--global", "--unset-all", "user.email"], allow_fail=True)
+        
+        os.remove(key_path)
+        os.remove(str(key_path) + '.pub')
+        success("User successfully logout")
+        return True
+    except Exception as e:
+        error(f"Failed to remove SSH keys\nCAUSE OF ERROR: {e}")
+        return False

pygitgo/auth/ssh_utils.py

@@ -0,0 +1,114 @@
+from pygitgo.utils.executor import run_command
+from pygitgo.utils.colors import info, success, warning, error
+from pygitgo.utils import platform_utils
+from pathlib import Path
+import sys
+import os
+
+
+
+def ensure_github_known_host():
+    known_hosts = Path.home() / ".ssh" / "known_hosts"
+    known_hosts.parent.mkdir(parents=True, exist_ok=True)
+
+    try:
+        if known_hosts.exists():
+            with open(known_hosts, "r") as f:
+                if "github.com" in f.read():
+                    return 
+    except Exception:
+        pass
+
+    info("Adding GitHub to known_hosts...")
+    result = run_command(["ssh-keyscan", "-H", "github.com"], allow_fail=True, return_complete=True)
+    
+    if not isinstance(result, Exception) and result.stdout and "github.com" in result.stdout:
+        with open(known_hosts, "a") as f:
+            f.write(result.stdout)
+            if not result.stdout.endswith("\n"):
+                f.write("\n")
+        success("GitHub added to known_hosts.")
+    else:
+        warning("Could not automatically add GitHub to known_hosts. You might be prompted.")
+
+def check_connection():
+    ensure_github_known_host()
+    result = run_command(["ssh", "-T", "git@github.com"], allow_fail=True, return_complete=True)
+    return "successfully authenticated" in result.stderr
+
+def get_github_username():
+
+    result = run_command(["ssh", "-T", "git@github.com"], allow_fail=True, return_complete=True)
+    output = result.stderr
+    
+    if "Hi " in output and "!" in output:
+        try:
+            username = output.split("Hi ")[1].split("!")[0]
+            return username
+        except:
+            return None
+    return None
+
+def get_ssh_key_path():
+    return Path.home() / ".ssh" / "id_ed25519"
+
+def generate_ssh_key(email):
+    if not email or "@" not in email or "." not in email:
+        error("Invalid email address provided for SSH key generation.")
+        return 
+    
+    key_path = get_ssh_key_path()
+    if not key_path.parent.exists():
+        key_path.parent.mkdir(parents=True)
+    
+    if key_path.exists():
+        os.remove(key_path)
+    if (key_path.parent / f"{key_path.name}.pub").exists():
+        os.remove(key_path.parent / f"{key_path.name}.pub")
+
+    command = [
+        "ssh-keygen",
+        "-t", "ed25519",
+        "-C", email,
+        "-f", str(key_path),
+        "-N", ""
+    ]
+    run_command(command=command)
+
+    try:
+        run_command(["ssh-add", str(key_path)], allow_fail=True)
+    except:
+        pass 
+    
+    return key_path
+
+def open_github_settings():
+    url = "https://github.com/settings/ssh/new"
+    if platform_utils.is_windows():
+        os.system(f"start {url}")
+    elif platform_utils.is_termux():
+        os.system(f"termux-open {url}")
+    elif platform_utils.is_linux() or platform_utils.is_macos():
+        os.system(f"xdg-open {url}")
+    else:
+        import webbrowser
+        webbrowser.open(url)
+
+
+def convert_https_to_ssh(url):
+
+    import re
+    
+    pattern = r'^https?://github\.com/([^/]+)/([^/]+?)(?:\.git)?/?$'
+    match = re.match(pattern, url.strip())
+    
+    if match:
+        owner = match.group(1)
+        repo = match.group(2)
+        return f"git@github.com:{owner}/{repo}.git"
+    
+    return None
+
+
+def is_ssh_url(url):
+    return url.strip().startswith("git@")

pygitgo/commands/git_operations.py

@@ -0,0 +1,148 @@
+from pygitgo.auth.ssh_utils import convert_https_to_ssh, is_ssh_url, check_connection
+from pygitgo.utils.executor import run_command
+from pygitgo.utils.colors import info, success, warning, error
+import subprocess
+import sys
+import os
+
+DEFAULT_MAIN_BRANCH = "main"
+
+
+def get_current_branch():
+    branch = run_command(["git", "branch", "--show-current"])
+    if branch.strip() == "":
+        branch = git_new_branch(DEFAULT_MAIN_BRANCH)
+
+    return branch
+
+def is_branch_exist(branch):
+    return bool(run_command(["git", "branch", "-r", "--list", f"*/{branch}"])) or bool(run_command(["git", "branch", "--list", branch]))
+
+
+def git_new_branch(branch):
+    run_command(["git", "checkout", "-b", branch], loading_msg=f"Creating branch '{branch}'...")
+    success(f"\nBranch '{branch}' created.\n")
+
+    return branch
+
+
+def git_commit(commit_message):
+    status_result = run_command(["git", "status", "--porcelain"], allow_fail=True)
+    if isinstance(status_result, subprocess.CalledProcessError) or not status_result.strip():
+        return False
+
+    run_command(["git", "add", "."], loading_msg="Staging files...")
+    clean_message = commit_message.strip('"\'')
+    
+    run_command(["git", "commit", "-m", clean_message], loading_msg="Committing changes...")
+
+    return True
+
+
+def git_init():
+    if os.path.isdir(".git"):
+        warning("Already a git repository! Skipping init...")
+        return True
+    
+    result = run_command(["git", "init", "-b", DEFAULT_MAIN_BRANCH], allow_fail=True, loading_msg="Initializing git repository...")
+    if isinstance(result, subprocess.CalledProcessError):
+        run_command(["git", "init"], loading_msg="Initializing git repository...")
+        run_command(["git", "checkout", "-b", DEFAULT_MAIN_BRANCH], allow_fail=True)
+
+    success("Git repository initialized.")
+    return True
+
+
+def add_remote_origin(repo_url):
+    clean_url = repo_url.strip('"\'')
+    
+    existing_remote = run_command(["git", "remote", "get-url", "origin"], allow_fail=True)
+    if not isinstance(existing_remote, subprocess.CalledProcessError):
+        warning(f"Remote origin already exists: {existing_remote}")
+        run_command(["git", "remote", "set-url", "origin", clean_url], loading_msg="Updating remote URL...")
+    else:
+        run_command(["git", "remote", "add", "origin", clean_url], loading_msg="Adding remote origin...")
+    
+    success(f"Remote origin set to: {clean_url}")
+
+
+def confirm_remote_link():
+    test_result = run_command(["git", "ls-remote", "origin"], allow_fail=True, loading_msg="Testing connection to remote...")
+    
+    if isinstance(test_result, subprocess.CalledProcessError):
+        error("Failed to connect to remote repository!")
+        warning("Please check your repository URL and network connection.")
+        return False
+    
+    success("Successfully connected to remote repository.")
+    return True
+
+
+def create_main_branch():
+    current_branch = run_command(["git", "branch", "--show-current"], allow_fail=True)
+    
+    if isinstance(current_branch, subprocess.CalledProcessError) or not current_branch.strip():
+        run_command(["git", "checkout", "-b", "main"], loading_msg="Setting default branch to 'main'...")
+    elif current_branch.strip() != "main":
+        run_command(["git", "branch", "-m", "main"], loading_msg=f"Renaming branch '{current_branch.strip()}' to 'main'...")
+    else:
+        success("Already on 'main' branch.")
+
+
+def check_and_sync_branch(branch):
+    try:
+        run_command(["git", "fetch", "origin"], loading_msg="Checking if branch is up to date...")
+
+        try:
+            local_commit = run_command(["git", "rev-parse", branch])
+            remote_commit = run_command(["git", "rev-parse", f"origin/{branch}"])
+
+            if local_commit != remote_commit:
+                behind_check = run_command(
+                    ["git", "rev-list", "--count", f"{branch}..origin/{branch}"]
+                )
+                if behind_check and int(behind_check) > 0:
+                    warning(f"Local branch is behind remote by {behind_check} commit(s). Pulling changes...")
+                    output = run_command(["git", "pull", "--rebase", "origin", branch], loading_msg="Pulling changes from remote...")
+                    if output:
+                        print(output)
+                    success("Successfully synced with remote!")
+                else:
+                    success("Branch is up to date or ahead of remote.")
+            else:
+                success("Branch is already up to date.")
+        except:
+            warning("Remote branch doesn't exist yet. First push will create it.")
+    except:
+        warning("Could not fetch from remote. Proceeding with push...")
+
+
+def git_push(branch):
+    remote_url = run_command(["git", "remote", "get-url", "origin"], allow_fail=True)
+    
+    if not isinstance(remote_url, subprocess.CalledProcessError) and remote_url:
+        remote_url = remote_url.strip()
+        
+        if not is_ssh_url(remote_url) and check_connection():
+            ssh_url = convert_https_to_ssh(remote_url)
+            if ssh_url:
+                run_command(["git", "remote", "set-url", "origin", ssh_url], loading_msg="Converting remote from HTTPS to SSH for secure push...")
+                success(f"Remote updated to: {ssh_url}")
+    
+    run_command(["git", "push", "-u", "origin", branch], loading_msg=f"Pushing to remote branch '{branch}'...")
+
+
+def handle_rebase():
+    status = run_command(["git", "status"], allow_fail=True)
+    if isinstance(status, subprocess.CalledProcessError):
+        return False
+
+    if "rebase in progress" in status or "rebase" in status.lower():
+        warning("\nConflict detected!")
+        warning("Please resolve conflicts manually, then run:")
+        info("    git add <files>")
+        info("    git rebase --continue")
+        warning("When finished, run 'gitgo push <branch> <message>' again.\n")
+        sys.exit(1)
+
+    return True

pygitgo/commands/state.py

@@ -0,0 +1,193 @@
+from pygitgo.utils.executor import run_command
+from pygitgo.utils.colors import info, highlight, error, warning, success
+import sys
+
+
+def all_save_state():
+    output = run_command(["git", "stash", "list", "--pretty=%gd: %s"])
+    if not output:
+        info("\nNo saved states found.\n")
+        sys.exit(0)
+
+    save_states = [result[6:] for result in output.splitlines()]
+    
+    return save_states
+
+
+def display_save_states():
+    save_states = all_save_state()
+
+    print("\nSaved States:")
+    print("-" * 32)
+    for state in save_states:
+        state_index = state.split(': ', 1)[0].replace("stash@", "").replace("{", "").replace("}", "")
+        highlight(f"{int(state_index) + 1} | {state.split(': ', 1)[1]}")
+
+    print("-" * 32 + '\n')
+
+
+def validate_state_id(state_id, save_states):
+    if not state_id.isdigit():
+        error("\nInvalid input. Please enter a valid state ID.\n")
+        return False
+    elif (int(state_id) - 1) < 0:
+        error("\nState ID cannot be negative. Please enter a valid state ID.\n")
+        return False
+    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
+
+
+def ask_state_id(save_states):
+    proceed = False
+    state_id = None
+
+    while not proceed:
+        state_id = input(">> ").strip().lower()
+        if state_id == 'q':
+            warning("\nLoad operation cancelled by user.\n")
+            sys.exit(0)
+        proceed = validate_state_id(state_id, save_states)
+    
+    return state_id
+
+
+def state_list(arguments):
+    if len(arguments) > 1:
+        if arguments[1] in ("-h", "--help", "help"):
+            print("\nDisplay all saved states.\n")
+            warning("\nUsage:\n")
+            print("  gitgo state list        # Show all saved states")
+            print("  gitgo state -l          # Alias\n")
+            sys.exit(0)
+        error("\nToo many arguments for list operation!\n")
+        sys.exit(1)
+
+    display_save_states()
+
+
+def load_state(arguments):
+    if len(arguments) > 2:
+        error("\nToo many arguments for load operation!\n")
+        sys.exit(1)
+
+    save_states = all_save_state()
+    proceed = False
+    state_id = None
+
+    if len(arguments) == 2:
+        if arguments[1] in ("-h", "--help", "help"):
+            print("\nLoad a previously saved working state.\n")
+            warning("\nUsage:\n")
+            print("  gitgo state load <id>   # Load a specific state by ID")
+            print("  gitgo state load        # Show all saved states and prompt for selection")
+            print("  gitgo state -o <id>     # Alias\n")
+            sys.exit(0)
+        elif arguments[1].isdigit():
+            state_id = arguments[1]
+            proceed = validate_state_id(state_id, save_states)
+            if not proceed:
+                sys.exit(1)
+        else:
+            error(f"\nInvalid argument '{arguments[1]}' for load operation. Expected a state ID.\n")
+            sys.exit(1)
+    
+    if not proceed:
+        display_save_states()
+        info("\nEnter the ID of the state you want to load (or 'q' to cancel): ")
+        state_id = ask_state_id(save_states)
+        
+    run_command(["git", "stash", "apply", str(int(state_id) - 1)])
+
+    success(f"\nState '{save_states[int(state_id) - 1]}' loaded successfully.\n")
+
+
+def save_state(arguments):
+    if len(arguments) > 2:
+        error("\nToo many arguments for save operation!\n")
+        sys.exit(1)
+    elif len(arguments) < 2:
+        state_name = "Auto-Save"
+    
+    if len(arguments) == 2:
+        if arguments[1] in ("-h", "--help", "help"):
+            print("\nSave the current working state with an optional name.\n")
+            warning("\nUsage:\n")
+            print("  gitgo state save <name>   # Save with a specific name")
+            print("  gitgo state save          # Save with default name 'Auto-Save'")
+            print("  gitgo state -s <name>     # Alias\n")
+            sys.exit(0)
+            
+        state_name = arguments[1]
+
+    run_command(["git", "stash", "push", "-m", state_name])
+
+    success(f"\nState '{state_name}' saved successfully.\n")
+
+
+def delete_state(arguments):
+    if len(arguments) > 2:
+        error("\nToo many arguments for delete operation!\n")
+        sys.exit(1)
+    elif len(arguments) < 2:
+        state_id = ask_state_id(all_save_state())
+    else:
+        if arguments[1] in ("-h", "--help", "help"):
+            print("\nDelete one or all saved working states.\n")
+            warning("\nUsage:\n")
+            print("  gitgo state delete <id>   # Delete a specific state by ID")
+            print("  gitgo state delete -a     # Delete all saved states")
+            print("  gitgo state -d <id>       # Alias\n")
+            print("  gitgo state -d <id>       # Alias for delete all\n")
+            sys.exit(0)
+        
+        elif arguments[1] == '-a':
+            confirm = input("\nAre you sure you want to delete all saved states? (y/n): ").strip().lower()
+            if confirm.lower() == 'y':
+                run_command(["git", "stash", "clear"])
+                success("\nAll saved states deleted successfully.\n")
+                sys.exit(0)
+            else:
+                warning("\nDelete operation cancelled by user.\n")
+                sys.exit(0)
+        
+        elif not arguments[1].isdigit():
+            error("\nInvalid input. Please enter a valid state ID.\n")
+            sys.exit(1)
+
+        state_id = arguments[1]
+        if not validate_state_id(state_id, all_save_state()):
+            sys.exit(1)
+    
+    run_command(["git", "stash", "drop", str(int(state_id) - 1)])
+    success(f"\nState with ID '{state_id}' deleted successfully.\n")
+
+
+def state_operations_help():
+    warning("\nState Operations Help:\n")
+    print("  list, -l      Display all saved states.")
+    print("  load, -o      Load a previously saved working state.")
+    print("  save, -s      Save the current working state with a given name.")
+    print("  delete, -d    Delete a previously saved working state.\n")
+    info("Use 'gitgo state <operation> --help' for more information on a specific operation.\n")
+
+
+def state_operations(arguments):
+    if len(arguments) == 0 or arguments[0] in ("-h", "--help", "help"):
+        state_operations_help()
+        sys.exit(0)
+
+    type_of_operation = arguments[0].lower()
+    if type_of_operation in ["list", "-l"]:
+        state_list(arguments)
+    elif type_of_operation in ["load", "-o"]:
+        load_state(arguments)
+    elif type_of_operation in ["save", "-s"]:
+        save_state(arguments)
+    elif type_of_operation in ["delete", "-d"]:
+        delete_state(arguments)
+    else:
+        error(f"\nUnknown state operation: {type_of_operation}\n")
+        state_operations_help()
+        sys.exit(1)