pygitgo 1.8.0__tar.gz → 1.8.2__tar.gz

{pygitgo-1.8.0/src/pygitgo.egg-info → pygitgo-1.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygitgo
-Version: 1.8.0
+Version: 1.8.2
 Summary: GitGo CLI - Your Fast Git Companion. Simplifies git push, link, stash, and user management.
 Author: Huerte
 License: GPL-3.0-or-later

{pygitgo-1.8.0 → pygitgo-1.8.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pygitgo"
-version = "1.8.0"
+version = "1.8.2"
 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.8.0 → pygitgo-1.8.2}/src/pygitgo/auth/account.py

@@ -1,6 +1,7 @@
-from pygitgo.utils.colors import info, success, warning, error, BLUE, RESET
+from pygitgo.utils.cli_io import info, success, warning, error
 from pygitgo.utils.executor import run_command
 from pygitgo.exceptions import GitCommandError
+from pygitgo.utils.colors import BLUE, RESET
 
 
 def get_user():
@@ -24,7 +25,7 @@ def get_user():
 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")
+    success("\nGit user configured successfully.")
     print(f"{BLUE}Username{RESET} : {name}")
     print(f"{BLUE}Email    {RESET}: {email}")
 
@@ -65,3 +66,29 @@ def ensure_user_configure(default_email=None, default_username=None):
     error("Invalid configuration. Name and Email are required.")
     return False
 
+def sanitize_signing_config():
+    try:
+        gpgsign = run_command(["git", "config", "--global", "commit.gpgsign"]).strip().lower()
+    except GitCommandError:
+        return
+    
+    if gpgsign != "true":
+        return
+    
+    try:
+        fmt = run_command(["git", "config", "--global", "gpg.format"]).strip().lower()
+    except GitCommandError:
+        fmt = ""
+
+    if fmt == "ssh":
+        return
+    
+    warning("Detected 'commit.gpgsign=true' with no GPG key configured.")
+    warning("Disabling global GPG signing to prevent commit failures.")
+
+    try:
+        run_command(["git", "config", "--global", "--unset", "gpg.program"])
+    except GitCommandError:
+        pass
+    
+

pygitgo-1.8.2/src/pygitgo/auth/manager.py

@@ -0,0 +1,132 @@
+from pygitgo.utils.cli_io import info, success, warning, error
+from pygitgo.utils.platform import get_platform
+from pygitgo.utils.executor import run_command
+from pygitgo.exceptions import GitCommandError
+from pygitgo.utils.platform import open_url
+from . import ssh_utils
+import os
+
+
+def _configure_ssh_signing(key_path):
+    try:
+        run_command(["git", "config", "--global", "gpg.format", "ssh"])
+        run_command(["git", "config", "--global", "user.signingkey", str(key_path)])
+    except Exception:
+        pass
+    
+
+def login():
+    from .account import sanitize_signing_config, ensure_user_configure
+
+    sanitize_signing_config()
+
+    key_path = ssh_utils.get_ssh_key_path()
+    already_logged_in = key_path.exists()
+    ok_text = "Already logged in via GitGo." if already_logged_in else "GitHub connection verified."
+
+    if ssh_utils.check_connection(ok_text=ok_text, fail_text="Not connected to GitHub."):
+        if already_logged_in:
+            _configure_ssh_signing(key_path)
+            ensure_user_configure(default_username=ssh_utils.get_github_username())
+        else:
+            warning("GitHub SSH connection is active, but NOT via a GitGo-managed key.")
+            warning("To use GitGo's full login (SSH + verified commits), you must log out first.")
+            info("Run: gitgo user logout")
+            info("Then run: gitgo user login")
+
+        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 not pub_key:
+        error("Failed to read the generated public key.")
+        return False
+
+    success("SSH Key generated successfully!")
+
+    print()
+    print("  Your SSH public key:")
+    print()
+    print(f"  {pub_key.strip()}")
+    print()
+
+    info("Copy the key above, then add it TWICE on GitHub:")
+    info("  1. Authentication Key  (for pushing and pulling)")
+    info("  2. Signing Key         (for Verified commits)")
+    info("Same key text for both entries.")
+
+    input("\nOnce you've copied the key, press Enter to open GitHub...")
+
+    open_url("https://github.com/settings/ssh/new")
+
+    input(
+        "\nAfter adding both keys on GitHub,\n"
+        "come back here and press Enter to verify the connection..."
+    )
+
+    ssh_utils.clear_ssh_cache()
+
+    if ssh_utils.check_connection(ok_text="Login successful. You are connected.", fail_text="SSH key not recognised by GitHub."):
+        github_username = ssh_utils.get_github_username()
+        ensure_user_configure(default_email=email, default_username=github_username)
+        return True
+    
+    error("Login Failed. The SSH key may not have been added to GitHub correctly.")
+    info("Possible causes:")
+    info("  1. The key was not pasted on GitHub")
+
+    if get_platform() == "windows":
+        info("  2. SSH agent is not running — run in PowerShell (as Administrator):")
+        info("       Set-Service ssh-agent -StartupType Automatic")
+        info("       Start-Service ssh-agent")
+        info("     Then run 'gitgo user login' again.")
+    else:
+        info("  2. SSH agent is not running (try: eval $(ssh-agent) && ssh-add)")
+        
+    info("  3. Network or firewall is blocking SSH connections")
+    info("Need help? Full guide: https://github.com/Huerte/GitGo/blob/main/docs/login-guide.md")
+    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:
+        
+        os.remove(key_path)
+
+        pub_key_path = str(key_path) + ".pub"
+        if os.path.exists(pub_key_path):
+            os.remove(pub_key_path)
+
+        try:
+            run_command(["git", "config", "--global", "--unset-all", "user.name"], loading_msg="Clearing Git username...", ok_text="Git username cleared.")
+        except GitCommandError:
+            pass
+        
+        try:
+            run_command(["git", "config", "--global", "--unset-all", "user.email"], loading_msg="Clearing Git email...", ok_text="Git email cleared.")
+        except GitCommandError:
+            pass
+
+        success("User successfully logged out.")
+        return True
+    
+    except Exception as e:
+        error(f"Failed to remove SSH keys\nCAUSE OF ERROR: {e}")
+        return False

{pygitgo-1.8.0 → pygitgo-1.8.2}/src/pygitgo/auth/ssh_utils.py

@@ -1,14 +1,19 @@
 from pygitgo.exceptions import GitCommandError, GitGoError
-from pygitgo.utils.colors import info, success, warning
+from pygitgo.utils.cli_io import info, success, warning
+from pygitgo.utils.platform import get_platform
 from pygitgo.utils.executor import run_command
 from pathlib import Path
 import subprocess
+import time
 import os
 import re
 
 
 SSH_TIMEOUT_SECONDS = 10
 
+_cached_ssh_response = None
+_cache_populated = False
+
 
 def ensure_github_known_host():
     known_hosts = Path.home() / ".ssh" / "known_hosts"
@@ -47,13 +52,50 @@ def _get_github_ssh_response():
     except (subprocess.TimeoutExpired, OSError):
         return None
 
-def check_connection():
+
+def _get_cached_ssh_response():
+    global _cached_ssh_response, _cache_populated
+    if not _cache_populated:
+        _cached_ssh_response = _get_github_ssh_response()
+        _cache_populated = True
+    return _cached_ssh_response
+
+
+def clear_ssh_cache():
+    global _cached_ssh_response, _cache_populated
+    _cached_ssh_response = None
+    _cache_populated = False
+
+
+def check_connection(ok_text=None, fail_text=None):
+    from yaspin import yaspin
+    import sys
+    
     ensure_github_known_host()
-    output = _get_github_ssh_response()
-    return output is not None and "successfully authenticated" in output
+
+    kwargs = {"text": ok_text or "Verifying GitHub connection..."}
+    if sys.stdout.isatty():
+        kwargs["color"] = "cyan"
+    spinner = yaspin(**kwargs)
+    spinner.start()
+
+    output = _get_cached_ssh_response()
+    connected = output is not None and "successfully authenticated" in output
+
+    if connected:
+        if ok_text:
+            spinner.text = ok_text
+        spinner.ok("✔")
+    else:
+        if fail_text:
+            spinner.text = fail_text
+        spinner.fail("✖")
+
+    return connected
+
 
 def get_github_username():
-    output = _get_github_ssh_response()
+    output = _get_cached_ssh_response()
     if output and "Hi " in output and "!" in output:
         try:
             return output.split("Hi ")[1].split("!")[0]
@@ -73,6 +115,9 @@ def generate_ssh_key(email):
         key_path.parent.mkdir(parents=True)
     
     if key_path.exists():
+        from pygitgo.utils.cli_io import confirm
+        if not confirm(f"SSH key {key_path} already exists. Overwrite it? (y/n): ", destructive=True):
+            raise GitGoError("SSH key generation aborted. Please back up your existing key or configure it manually.")
         os.remove(key_path)
     if (key_path.parent / f"{key_path.name}.pub").exists():
         os.remove(key_path.parent / f"{key_path.name}.pub")
@@ -92,10 +137,8 @@ def generate_ssh_key(email):
             "\nFailed to generate SSH key. Is 'ssh-keygen' installed on your system?\n"
             f"Details: {e}"
         )
-    try:
-        run_command(["ssh-add", str(key_path)])
-    except (GitCommandError, OSError):
-        pass 
+    
+    ensure_ssh_agent(key_path, quiet=True)
     
     return key_path
 
@@ -114,3 +157,42 @@ def convert_https_to_ssh(url):
 
 def is_ssh_url(url):
     return url.strip().startswith("git@")
+
+def _try_ssh_add(key_path):
+    try:
+        run_command(["ssh-add", str(key_path)])
+        return True
+    except (GitCommandError, OSError):
+        return False
+
+def ensure_ssh_agent(key_path, quiet=False):
+    if _try_ssh_add(key_path):
+        return True
+    
+    if get_platform() == "windows":
+        try:
+            subprocess.run(
+                ["sc", "start", "ssh-agent"],
+                capture_output=True, timeout=5
+            )
+        except Exception:
+            pass
+
+        time.sleep(1)
+
+        if _try_ssh_add(key_path):
+            return True
+        
+        if not quiet:
+            warning("SSH agent is not running. Key may not persist across sessions.")
+            info("To fix this permanently, run in PowerShell (as Administrator):")
+            info("  Set-Service ssh-agent -StartupType Automatic")
+            info("  Start-Service ssh-agent")
+
+    else:
+        if not quiet:
+            warning("SSH agent is not running. Key may not persist across sessions.")
+            info("Run:  eval $(ssh-agent) && ssh-add")
+
+    return False
+    

{pygitgo-1.8.0 → pygitgo-1.8.2}/src/pygitgo/commands/config.py

@@ -1,5 +1,6 @@
 from pygitgo.utils.config import get_config, set_config
-from pygitgo.utils.colors import error, warning, info
+from pygitgo.utils.cli_io import warning, info
+from pygitgo.exceptions import GitGoError
 
 
 def config_operation(args):
@@ -10,14 +11,11 @@ def config_operation(args):
 
     VALID_KEYS = ["default-branch", "default-message"]
     if key not in VALID_KEYS:
-        error(f"\nInvalid configuration key: '{key}'")
-        warning(f"Valid keys are: {', '.join(VALID_KEYS)}\n")
-        return
+        raise GitGoError(f"Invalid configuration key: '{key}'. Valid keys are: {', '.join(VALID_KEYS)}")
 
     if action == 'set':
         if not value:
-            error("\nYou must provide a value to set!\n")
-            return
+            raise GitGoError("You must provide a value to set!")
         set_config(key, value)
     elif action == 'get':
         current_value = get_config(key, None)

{pygitgo-1.8.0 → pygitgo-1.8.2}/src/pygitgo/commands/git_branch.py

@@ -1,4 +1,4 @@
-from pygitgo.utils.colors import success, error, info
+from pygitgo.utils.cli_io import success, error, info, confirm
 from pygitgo.exceptions import GitCommandError, GitGoError
 from pygitgo.utils.executor import run_command
 from pygitgo.utils.config import get_config
@@ -30,11 +30,11 @@ 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):
+def git_new_branch(branch, ok_text=None):
     try:
-        run_command(["git", "checkout", "-b", branch], loading_msg=f"Creating branch '{branch}'...")
-        print()
-        success(f"Branch '{branch}' created.")
+        if not ok_text:
+            ok_text = f"Branch '{branch}' created."
+        run_command(["git", "checkout", "-b", branch], loading_msg=f"Creating branch '{branch}'...", ok_text=ok_text)
     except GitCommandError:
         try:
             current = get_current_branch()
@@ -44,9 +44,8 @@ def git_new_branch(branch):
         if current == branch:
             info(f"Already on branch '{branch}'. Continuing...")
         else:
-            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":
+            error(f"Failed to create branch '{branch}'. It may already exist.")
+            if confirm(f"Switch to the existing branch '{branch}' instead? (y/n): "):
                 from pygitgo.commands.jump import jump_operation
                 jump_operation(Namespace(branch=branch))
             else:

{pygitgo-1.8.0 → pygitgo-1.8.2}/src/pygitgo/commands/git_core.py

@@ -1,9 +1,10 @@
 from pygitgo.auth.ssh_utils import convert_https_to_ssh, get_ssh_key_path, is_ssh_url, check_connection
-from pygitgo.utils.colors import info, success, warning, error
 from pygitgo.exceptions import GitGoError, GitCommandError
+from pygitgo.auth.account import sanitize_signing_config
 from pygitgo.commands.git_remote import handle_rebase
 from pygitgo.utils.config import get_default_branch
 from pygitgo.utils.executor import run_command
+from pygitgo.utils.cli_io import info, warning
 import os
 
 
@@ -18,44 +19,52 @@ def _get_signing_flags():
     ]
 
 
-def git_commit(commit_message, loading_msg="Commiting changes...", skip_staging=False):
+def git_commit(commit_message, loading_msg="Committing changes...", skip_staging=False, ok_text=None):
+    if not ok_text:
+        ok_text = "Changes committed."
     try:
         status_result = run_command(["git", "status", "--porcelain"])
         if not status_result.strip():
             return False
     except GitCommandError:
         return False
+    
+    sanitize_signing_config()
 
     if not skip_staging:
-        run_command(["git", "add", "."], loading_msg="Staging files...")
+        run_command(["git", "add", "."], loading_msg="Staging files...", ok_text="Files staged.")
 
     clean_message = commit_message.strip('"\'')
 
     signing_flags = _get_signing_flags()
     commit_command = ["git"] + signing_flags + ["commit", "-S", "-m", clean_message]
-    run_command(commit_command, loading_msg=loading_msg)
+    run_command(commit_command, loading_msg=loading_msg, ok_text=ok_text)
 
     return True
 
 
-def git_init():
+def git_init(ok_text=None):
     if os.path.isdir(".git"):
         warning("Already a git repository! Skipping init...")
         return False
 
     default_main_branch = get_default_branch()
 
+    if not ok_text:
+        ok_text = "Git repository initialized."
+
     try:
-        run_command(["git", "init", "-b", default_main_branch], loading_msg="Initializing git repository...")
+        run_command(["git", "init", "-b", default_main_branch], loading_msg="Initializing git repository...", ok_text=ok_text)
     except GitCommandError:
         run_command(["git", "init"], loading_msg="Initializing git repository...")
-        run_command(["git", "checkout", "-b", default_main_branch])
+        run_command(["git", "checkout", "-b", default_main_branch], ok_text=ok_text)
 
-    success("Git repository initialized.")
     return True
 
 
-def git_push(branch):
+def git_push(branch, ok_text=None):
+    if not ok_text:
+        ok_text = f"Pushed to remote branch '{branch}'."
     try:
         remote_url = run_command(["git", "remote", "get-url", "origin"]).strip()
     except GitCommandError:
@@ -64,13 +73,11 @@ def git_push(branch):
     if remote_url and 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", "remote", "set-url", "origin", ssh_url], loading_msg="Converting remote from HTTPS to SSH for secure push...", ok_text=f"Remote updated to: {ssh_url}")
 
     try:
-        run_command(["git", "push", "-u", "origin", branch], loading_msg=f"Pushing to remote branch '{branch}'...")
+        run_command(["git", "push", "-u", "origin", branch], loading_msg=f"Pushing to remote branch '{branch}'...", ok_text=ok_text, err_text="Push failed: verify your remote URL and SSH key, then try again.")
     except (GitCommandError, OSError) as e:
-        error("Push failed — verify your remote URL and SSH key, then try again.")
         info("Run:  git remote -v   to inspect your current remote.")
         if "rebase in progress" in str(e):
             handle_rebase()

{pygitgo-1.8.0 → pygitgo-1.8.2}/src/pygitgo/commands/git_remote.py

@@ -1,5 +1,5 @@
-from pygitgo.utils.colors import info, success, warning, error
 from pygitgo.exceptions import GitCommandError, GitGoError
+from pygitgo.utils.cli_io import info, warning, error
 from pygitgo.utils.executor import run_command
 
 
@@ -9,30 +9,25 @@ def add_remote_origin(repo_url):
     try:
         existing_remote = run_command(["git", "remote", "get-url", "origin"])
         warning(f"Remote origin already exists: {existing_remote}")
-        run_command(["git", "remote", "set-url", "origin", clean_url], loading_msg="Updating remote URL...")
+        run_command(["git", "remote", "set-url", "origin", clean_url], loading_msg="Updating remote URL...", ok_text=f"Remote origin set to: {clean_url}")
     except GitCommandError:
-        run_command(["git", "remote", "add", "origin", clean_url], loading_msg="Adding remote origin...")
+        run_command(["git", "remote", "add", "origin", clean_url], loading_msg="Adding remote origin...", ok_text=f"Remote origin set to: {clean_url}")
 
-    success(f"Remote origin set to: {clean_url}")
 
-
-def confirm_remote_link():
+def confirm_remote_link(ok_text=None):
+    if not ok_text:
+        ok_text = "Remote is reachable."
     try:
-        run_command(["git", "ls-remote", "origin"], loading_msg="Testing connection to remote...")
-        success("Remote is reachable.")
+        run_command(["git", "ls-remote", "origin"], loading_msg="Testing connection to remote...", ok_text=ok_text)
         return True
     except GitCommandError:
-        error("Connection failed — verify the URL and your SSH key.")
         info("Run:  git remote -v   to inspect your current remote.")
-        return False
-
-
-
+        raise GitGoError("Connection failed — verify the URL and your SSH key.")
 
 
 def check_and_sync_branch(branch):
     try:
-        run_command(["git", "fetch", "origin"], loading_msg="Checking if branch is up to date...")
+        run_command(["git", "fetch", "origin"], loading_msg="Checking if branch is up to date...", ok_text="Remote fetched.")
 
         try:
             local_commit = run_command(["git", "rev-parse", branch])
@@ -44,14 +39,13 @@ def check_and_sync_branch(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...")
+                    output = run_command(["git", "pull", "--rebase", "origin", branch], loading_msg="Pulling changes from remote...", ok_text="Synced with remote.")
                     if output:
                         print(output)
-                    success("Synced with remote.")
                 else:
-                    success("Branch is up to date.")
+                    info("Branch is up to date.")
             else:
-                success("Branch is already up to date.")
+                info("Branch is already up to date.")
         except (GitCommandError, ValueError):
             warning("Remote branch doesn't exist yet. First push will create it.")
     except (GitCommandError, OSError):

{pygitgo-1.8.0 → pygitgo-1.8.2}/src/pygitgo/commands/init.py

@@ -1,6 +1,6 @@
 from pygitgo.commands.git_core import git_init
-from pygitgo.utils.colors import info, success
 from pygitgo.exceptions import GitGoError
+from pygitgo.utils.cli_io import info
 import urllib.request
 import urllib.error
 import zipfile
@@ -172,19 +172,31 @@ def _parse_template_slug(template):
 
 
 def _download_and_extract_template(template_slug, target_dir):
+    from yaspin import yaspin
+    import sys
     url = f"https://api.github.com/repos/{template_slug}/zipball"
     req = urllib.request.Request(url, headers={"User-Agent": "GitGo-CLI"})
-    info(f"Downloading template from GitHub: {template_slug}...")
+    kwargs = {"text": f"Downloading template from GitHub: {template_slug}..."}
+    if sys.stdout.isatty():
+        kwargs["color"] = "cyan"
+    spinner = yaspin(**kwargs)
+    spinner.start()
     try:
         with urllib.request.urlopen(req, timeout=30) as response:
             zip_data = response.read()
     except urllib.error.HTTPError as e:
         if e.code == 404:
+            spinner.text = f"Template '{template_slug}' not found on GitHub."
+            spinner.fail("✖")
             raise GitGoError(
                 f"Template repository '{template_slug}' not found on GitHub."
             )
+        spinner.text = f"Failed to download template: HTTP {e.code}"
+        spinner.fail("✖")
         raise GitGoError(f"Failed to download template: HTTP {e.code}")
     except Exception as e:
+        spinner.text = f"Network error downloading template: {e}"
+        spinner.fail("✖")
         raise GitGoError(f"Network error downloading template: {e}")
 
     try:
@@ -207,8 +219,11 @@ def _download_and_extract_template(template_slug, target_dir):
                     os.makedirs(os.path.dirname(dest), exist_ok=True)
                     with zf.open(member) as src, open(dest, "wb") as out:
                         out.write(src.read())
-        success("Template extracted successfully.")
+        spinner.text = "Template extracted successfully."
+        spinner.ok("✔")
     except Exception as e:
+        spinner.text = f"Failed to extract template: {e}"
+        spinner.fail("✖")
         raise GitGoError(f"Failed to extract template: {e}")
 
 
@@ -277,7 +292,7 @@ def _scaffold_language(lang, target_dir, name):
         info(f"Created {name}.csproj and Program.cs")
 
 
-def init_operation(args):
+def init_operation(args, standalone=False):
     target_dir = args.name
 
     if os.path.exists(target_dir) and os.listdir(target_dir):
@@ -294,10 +309,12 @@ def init_operation(args):
             _scaffold_language(args.lang, target_dir, target_dir)
 
         os.chdir(target_dir)
-        git_init()
+        git_init(ok_text=f"Initialized empty Git repository in {os.path.abspath('.')}")
 
-        success(f"\nInitialized empty Git repository in {os.path.abspath('.')}")
-        info("Next step: Create a remote repo with 'gitgo new <name>'")
+        if standalone:
+            from pygitgo.utils.cli_io import banner
+            banner("LOCAL SCAFFOLD CONSTRUCTED.", "PROJECT STRUCTURE AND REPOSITORY INITIALIZED.")
+            info(f"Next steps:\n  cd {target_dir}\n  gitgo repo\n  gitgo link <url>")
 
     except Exception as e:
         if os.path.exists(target_dir) and not os.listdir(target_dir):