giddy-cli 0.1.0__py3-none-any.whl

giddy/__init__.py

@@ -0,0 +1,4 @@
+"""Interactive Git assistant CLI."""
+
+__version__ = "0.1.0"
+__author__ = "Antoine"

giddy/cli.py

@@ -0,0 +1,169 @@
+from InquirerPy import inquirer
+from InquirerPy.validator import EmptyInputValidator
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+from giddy.config import load_config
+from giddy.git import get_current_branch, get_modified_files
+
+
+def ask_commit_details() -> str:
+    """Interactively prompt for commit details using conventional commits format.
+
+    Returns:
+        A formatted commit message following conventional commits format.
+    """
+    config = load_config()
+    defined_scopes = config.get("commits", {}).get("scopes", [])
+
+    commit_type_full = inquirer.select(
+        message="What type of change did you make?",
+        choices=[
+            "feat     ✨ (New feature)",
+            "fix      🐛 (Bug fix)",
+            "refactor 🔨 (Code improvement)",
+            "docs     📚 (Documentation)",
+            "chore    🧹 (Dependencies, configuration)",
+        ],
+        pointer="👉",
+    ).execute()
+
+    commit_type = commit_type_full.split()[0]
+
+    if defined_scopes:
+        # If scopes are defined in config, show a dropdown menu
+        choices = ["(none)"] + defined_scopes
+        scope_choice = inquirer.select(
+            message="Select the scope of this change:", choices=choices, pointer="👉"
+        ).execute()
+        scope = "" if scope_choice == "(none)" else scope_choice
+    else:
+        # Default behavior: free text input
+        scope = inquirer.text(
+            message="Scope of this change (e.g., api, ui - Enter to skip):"
+        ).execute()
+
+    description = inquirer.text(
+        message="Describe your change (in lowercase without ending punctuation):",
+        validate=EmptyInputValidator("Description is required!"),
+    ).execute()
+
+    # Format final commit message
+    scope_str = f"({scope.strip()})" if scope.strip() else ""
+    return f"{commit_type}{scope_str}: {description.strip()}"
+
+
+def show_dashboard() -> None:
+    """Display repository status dashboard.
+
+    Shows current branch, modified files, and next steps.
+    """
+    console = Console()
+    branch = get_current_branch()
+    files = get_modified_files()
+
+    # If working tree is clean
+    if not files:
+        message = Text(
+            "\n✨ Your working directory is clean on branch '", style="green"
+        )
+        message.append(branch, style="bold cyan")
+        message.append("'.\nNothing to commit!", style="green")
+        console.print(
+            Panel(
+                message,
+                title="[bold green]🐎 Giddy Status[/bold green]",
+                border_style="green",
+            )
+        )
+        return
+
+    # If there are modifications
+    content = Text("Current branch: ", style="white")
+    content.append(f"{branch}\n\n", style="bold cyan")
+    content.append("📝 Modified files:\n", style="bold yellow")
+
+    for file_line in files:
+        # Git --porcelain format: " M filename.py" or "?? newfile.txt"
+        state = file_line[:2]
+        file_name = file_line[3:]
+
+        if "??" in state:
+            content.append("  🆕 Untracked  ", style="blue")
+        elif "M" in state:
+            content.append("  🛠️  Modified   ", style="yellow")
+        elif "D" in state:
+            content.append("  ❌ Deleted    ", style="red")
+        elif "A" in state:
+            content.append("  ✅ Added      ", style="green")
+        else:
+            content.append(f"  📄 {state.strip()}      ", style="white")
+
+        content.append(f"{file_name}\n", style="white")
+
+    content.append("\n👉 Run ", style="dim")
+    content.append("giddy done", style="bold green")
+    content.append(" to commit and push these changes.", style="dim")
+
+    console.print(
+        Panel(
+            content,
+            title="[bold yellow]🐎 Giddy Status[/bold yellow]",
+            border_style="yellow",
+        )
+    )
+
+
+def ask_files_to_stage() -> list[str]:
+    """
+    Prompts the user to select specific files to stage for the commit.
+
+    Retrieves the list of modified/untracked files using Git porcelain format.
+    Displays an interactive checkbox menu. The user can press 'Space' to select
+    individual files, or 'a' to select all.
+
+    Returns:
+        list[str]: A list of file paths selected by the user. Returns an empty
+                   list if no files are modified or selected.
+    """
+    raw_files = get_modified_files()
+
+    if not raw_files:
+        return []
+
+    # Prepare choices for InquirerPy:
+    # 'name' is what the user sees (e.g., " M src/main.py")
+    # 'value' is what the program gets (e.g., "src/main.py")
+    choices = []
+    for line in raw_files:
+        file_path = line[3:].strip()
+        choices.append({"name": line, "value": file_path})
+
+    selected_files = inquirer.checkbox(
+        message="Which files do you want to commit?",
+        choices=choices,
+        instruction="(Press <Space> to select, <Alt+a> to toggle all, <Enter> to confirm)",
+    ).execute()
+
+    return selected_files
+
+
+def ask_branch_to_switch(branches: list[str], current_branch: str) -> str:
+    """Prompt the user to fuzzy-search and select a branch."""
+
+    # Optional: Remove the current branch from the list
+    # so they don't switch to where they already are
+    available_branches = [b for b in branches if b != current_branch]
+
+    if not available_branches:
+        print("🐎 No other branches found!")
+        return ""
+
+    branch = inquirer.fuzzy(
+        message="Which branch do you want to switch to?",
+        choices=available_branches,
+        instruction="(Start typing to search, Enter to select)",
+    ).execute()
+
+    return branch

giddy/config.py

@@ -0,0 +1,76 @@
+import os
+
+import tomllib
+
+DEFAULT_CONFIG = {
+    "core": {
+        "base_branch": "main",
+    },
+    "commits": {"scopes": []},
+}
+
+
+def load_config() -> dict:
+    """Load the local config or return the default."""
+    if not os.path.exists(".giddy.toml"):
+        return DEFAULT_CONFIG
+
+    try:
+        with open(".giddy.toml", "rb") as f:
+            user_config = tomllib.load(f)
+
+            merged = DEFAULT_CONFIG.copy()
+            if "core" in user_config:
+                merged["core"].update(user_config["core"])
+            if "commits" in user_config:
+                merged["commits"].update(user_config["commits"])
+            return merged
+
+    except Exception as e:
+        print(f"⚠️ Error reading .giddy.toml : {e}. Using default values.")
+        return DEFAULT_CONFIG
+
+
+CONFIG_TEMPLATE = """# ==========================================
+# Giddy Configuration
+# ==========================================
+
+[core]
+# The main branch of your repository where PRs are merged.
+# Default: "main"
+base_branch = "main"
+
+[commits]
+# Define a list here to transform the 'scope' question into a dropdown menu.
+# Example: scopes = ["api", "ui", "database", "docs"]
+# Default: [] (Leaves a free text input)
+scopes = []
+"""
+
+
+def init_config() -> None:
+    """
+    Generates a default .giddy.toml configuration file.
+
+    Checks if the configuration file already exists in the current working
+    directory to prevent accidental overwrites. If it does not exist, it
+    creates the file with a pre-filled template containing default settings
+    and explanatory comments.
+
+    Returns:
+        None
+    """
+    config_path = ".giddy.toml"
+
+    if os.path.exists(config_path):
+        print(f"\n⚠️  The file \033[93m{config_path}\033[0m already exists.")
+        print(
+            "   If you want to start fresh, delete it first and run 'giddy init' again."
+        )
+        return
+
+    with open(config_path, "w", encoding="utf-8") as f:
+        f.write(CONFIG_TEMPLATE)
+
+    print(f"\n🎉 Success! A \033[92m{config_path}\033[0m file has been generated.")
+    print("   You can open it and customize Giddy's behavior for this repository.")

giddy/git.py

@@ -0,0 +1,177 @@
+import subprocess
+
+
+def run_git_command(command: list[str]) -> bool:
+    """Execute a Git command silently. Returns True if successful."""
+    try:
+        subprocess.run(command, check=True, capture_output=True)
+        return True
+    except subprocess.CalledProcessError:
+        return False
+
+
+def get_current_branch() -> str:
+    """Get the current Git branch name."""
+    result = subprocess.run(
+        ["git", "branch", "--show-current"], capture_output=True, text=True
+    )
+    return result.stdout.strip()
+
+
+def get_modified_files() -> list[str]:
+    """Get list of modified files using Git's porcelain format."""
+    result = subprocess.run(
+        ["git", "status", "--porcelain", "-uall"], capture_output=True, text=True
+    )
+    return result.stdout.splitlines()
+
+
+def get_local_branches() -> list[str]:
+    """Get a list of local branches sorted by recent commit date."""
+    try:
+        result = subprocess.run(
+            [
+                "git",
+                "for-each-ref",
+                "--sort=-committerdate",
+                "--format=%(refname:short)",
+                "refs/heads/",
+            ],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        output = result.stdout.strip()
+        if not output:
+            return []
+        return [branch.strip() for branch in output.split("\n") if branch.strip()]
+    except subprocess.CalledProcessError:
+        return []
+
+
+def switch_to_branch(branch_name: str) -> bool:
+    """Switch to an existing branch."""
+    return run_git_command(["git", "checkout", branch_name])
+
+
+def get_remote_repo_info() -> tuple[str, str]:
+    """Extracts the repository URL and provider."""
+    result = subprocess.run(
+        ["git", "config", "--get", "remote.origin.url"], capture_output=True, text=True
+    )
+    url = result.stdout.strip()
+
+    if not url:
+        return "", ""
+
+    if "github.com" in url:
+        clean_path = (
+            url.replace("git@github.com:", "")
+            .replace("https://github.com/", "")
+            .replace(".git", "")
+        )
+        return f"https://github.com/{clean_path}", "github"
+
+    if "gitlab.com" in url:
+        clean_path = (
+            url.replace("git@gitlab.com:", "")
+            .replace("https://gitlab.com/", "")
+            .replace(".git", "")
+        )
+        return f"https://gitlab.com/{clean_path}", "gitlab"
+
+    return "", ""
+
+
+# -------------------------------------------------------------------
+# ACTIONS
+# -------------------------------------------------------------------
+
+
+def create_and_checkout_branch(branch_name: str) -> bool:
+    """Create a new branch and switch to it."""
+    return run_git_command(["git", "checkout", "-b", branch_name])
+
+
+def fetch_and_prune() -> bool:
+    """Fetch from origin and prune deleted remote branches."""
+    return run_git_command(["git", "fetch", "-p"])
+
+
+def pull_changes() -> bool:
+    """Pull the latest changes from the remote repository."""
+    return run_git_command(["git", "pull"])
+
+
+def stage_files(files: list[str]) -> bool:
+    """Stage specific files for commit."""
+    return run_git_command(["git", "add"] + files)
+
+
+def commit_changes(message: str) -> bool:
+    """Create a commit with the staged files."""
+    return run_git_command(["git", "commit", "-m", message])
+
+
+def push_head() -> bool:
+    """Push the current branch to origin."""
+    return run_git_command(["git", "push", "origin", "HEAD"])
+
+
+def stash_push(message: str) -> bool:
+    """Stash modifications and untracked files with a message."""
+    return run_git_command(["git", "stash", "push", "-u", "-m", message])
+
+
+def stash_pop() -> bool:
+    """Pop the latest stashed changes. Returns True if no conflicts."""
+    try:
+        subprocess.run(
+            ["git", "stash", "pop"], capture_output=True, text=True, check=True
+        )
+        return True
+    except subprocess.CalledProcessError:
+        return False
+
+
+def get_merged_branches() -> list[str]:
+    """Get a list of branches that have already been merged into the current branch."""
+    result = subprocess.run(
+        ["git", "branch", "--merged"], capture_output=True, text=True
+    )
+    return [
+        b.strip().replace("* ", "") for b in result.stdout.splitlines() if b.strip()
+    ]
+
+
+def delete_local_branch(branch_name: str) -> bool:
+    """Delete a local branch."""
+    # Using lowercase -d is safe: Git will refuse to delete if it's not merged!
+    return run_git_command(["git", "branch", "-d", branch_name])
+
+
+def undo_last_commit() -> bool:
+    """Undo the last commit but keep files in the working directory."""
+    return run_git_command(["git", "reset", "--soft", "HEAD~1"])
+
+
+def get_tracked_files() -> list[str]:
+    """Get a list of all files currently tracked by Git."""
+    result = subprocess.run(["git", "ls-files"], capture_output=True, text=True)
+    return result.stdout.splitlines()
+
+
+def untrack_file(file_path: str) -> bool:
+    """Remove a file from Git tracking without deleting it locally."""
+    # -r is for recursive (if it's a directory), --cached keeps the local file
+    return run_git_command(["git", "rm", "-r", "--cached", file_path])
+
+
+def commit_amend() -> bool:
+    """Amend the last commit without changing its message."""
+    return run_git_command(["git", "commit", "--amend", "--no-edit"])
+
+
+def push_force() -> bool:
+    """Force push safely using --force-with-lease."""
+    return run_git_command(["git", "push", "--force-with-lease", "origin", "HEAD"])

giddy/main.py

@@ -0,0 +1,125 @@
+import argparse
+import subprocess
+import sys
+
+# On importe nos belles briques !
+from giddy.git import get_current_branch, get_modified_files
+from giddy.ui import show_dashboard, show_error
+from giddy.utils import init_config
+from giddy.workflows import (
+    amend_workflow,
+    commit_workflow,
+    start_workflow,
+    switch_workflow,
+    sync_workflow,
+    undo_workflow,
+    untrack_workflow,
+)
+
+
+def check_git_environment(command: str) -> None:
+    """Check if Git is installed and if the current directory is a Git repository."""
+    if command == "init":
+        return
+
+    # 1. Check if Git is installed
+    try:
+        subprocess.run(["git", "--version"], capture_output=True, check=True)
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        show_error("Git is not installed or not accessible in your PATH.")
+        sys.exit(1)
+
+    # 2. Check if we are inside a Git repository
+    try:
+        subprocess.run(
+            ["git", "rev-parse", "--is-inside-work-tree"],
+            capture_output=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError:
+        show_error("This directory is not a Git repository. Run 'git init' first.")
+        sys.exit(1)
+
+
+def app() -> None:
+    """Main entry point for the Giddy Git assistant CLI."""
+    try:
+        if sys.platform == "win32":
+            import os
+
+            os.system("")
+
+        parser = argparse.ArgumentParser(
+            description="Interactive Git assistant to simplify your workflow."
+        )
+        subparsers = parser.add_subparsers(dest="command", required=True)
+
+        subparsers.add_parser("start", help="Create and checkout a new feature branch.")
+
+        subparsers.add_parser(
+            "done", help="Create a commit and push changes to remote."
+        )
+        subparsers.add_parser(
+            "status", help="Display repository status and modified files."
+        )
+        subparsers.add_parser(
+            "sync",
+            help="Switch back to main, pull updates, and clean up dead branches.",
+        )
+        subparsers.add_parser(
+            "init", help="Generate a default .giddy.toml configuration file."
+        )
+        subparsers.add_parser("switch", help="Switch to a different branch.")
+        subparsers.add_parser(
+            "undo", help="Undo the last commit without losing your changes."
+        )
+        subparsers.add_parser(
+            "untrack", help="Stop tracking a file in Git without deleting it locally."
+        )
+        subparsers.add_parser(
+            "amend", help="Quickly add forgotten files to your last commit."
+        )
+
+        args = parser.parse_args()
+
+        # Check environment before proceeding
+        check_git_environment(args.command)
+
+        # Dispatch to the right workflow!
+        if args.command == "start":
+            start_workflow()
+
+        elif args.command == "done":
+            commit_workflow()
+
+        elif args.command == "status":
+            branch = get_current_branch()
+            files = get_modified_files()
+            show_dashboard(branch, files)
+
+        elif args.command == "sync":
+            sync_workflow()
+
+        elif args.command == "init":
+            init_config()
+
+        elif args.command == "switch":
+            switch_workflow()
+
+        elif args.command == "undo":
+            undo_workflow()
+
+        elif args.command == "untrack":
+            untrack_workflow()
+
+        elif args.command == "amend":
+            amend_workflow()
+
+    except KeyboardInterrupt:
+        # Gracefully handle Ctrl+C
+        print("\n\n🛑 Operation cancelled. No changes were made.\n")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    app()