panqake 0.1.0__py3-none-any.whl

panqake/__init__.py

@@ -0,0 +1,3 @@
+"""Panqake - Git branch stacking utility."""
+
+__version__ = "0.1.0"

panqake/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running the package directly with python -m panqake."""
+
+from panqake.cli import main
+
+if __name__ == "__main__":
+    main()

panqake/cli.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""
+Panqake - Git Branch Stacking Utility
+A Python implementation of git-stacking workflow management
+"""
+
+import argparse
+import sys
+
+from panqake.commands.delete import delete_branch
+from panqake.commands.list import list_branches
+from panqake.commands.new import create_new_branch
+from panqake.commands.pr import create_pull_requests
+from panqake.commands.switch import switch_branch
+from panqake.commands.update import update_branches
+from panqake.utils.config import init_panqake
+from panqake.utils.git import is_git_repo
+
+
+def main():
+    """Main entry point for the panqake CLI."""
+    parser = argparse.ArgumentParser(
+        description="Panqake - Git Branch Stacking Utility"
+    )
+    subparsers = parser.add_subparsers(dest="command", help="Command to run")
+
+    # new command
+    new_parser = subparsers.add_parser("new", help="Create a new branch in the stack")
+    new_parser.add_argument(
+        "branch_name",
+        nargs="?",
+        help="Name of the new branch to create",
+    )
+    new_parser.add_argument(
+        "base_branch",
+        nargs="?",
+        help="Optional base branch (defaults to current branch)",
+    )
+
+    # list command
+    list_parser = subparsers.add_parser("list", help="List the branch stack")
+    list_parser.add_argument(
+        "branch_name",
+        nargs="?",
+        help="Optional branch to start from (defaults to current branch)",
+    )
+
+    # update command
+    update_parser = subparsers.add_parser(
+        "update", help="Update branches after changes"
+    )
+    update_parser.add_argument(
+        "branch_name",
+        nargs="?",
+        help="Optional branch to start from (defaults to current branch)",
+    )
+
+    # delete command
+    delete_parser = subparsers.add_parser(
+        "delete", help="Delete a branch and relink the stack"
+    )
+    delete_parser.add_argument("branch_name", help="Name of the branch to delete")
+
+    # pr command
+    pr_parser = subparsers.add_parser("pr", help="Create PRs for the branch stack")
+    pr_parser.add_argument(
+        "branch_name",
+        nargs="?",
+        help="Optional branch to start from (defaults to current branch)",
+    )
+
+    # switch command
+    switch_parser = subparsers.add_parser(
+        "switch", help="Interactively switch between branches"
+    )
+    switch_parser.add_argument(
+        "branch_name",
+        nargs="?",
+        help="Optional branch to switch to (defaults to interactive selection)",
+    )
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        return
+
+    # Initialize panqake directory and files
+    init_panqake()
+
+    # Check if we're in a git repository
+    if not is_git_repo():
+        print("Error: Not in a git repository")
+        sys.exit(1)
+
+    # Execute the appropriate command
+    if args.command == "new":
+        create_new_branch(args.branch_name, args.base_branch)
+    elif args.command == "list":
+        list_branches(args.branch_name)
+    elif args.command == "update":
+        update_branches(args.branch_name)
+    elif args.command == "delete":
+        delete_branch(args.branch_name)
+    elif args.command == "pr":
+        create_pull_requests(args.branch_name)
+    elif args.command == "switch":
+        switch_branch(args.branch_name)
+
+
+if __name__ == "__main__":
+    main()

panqake/commands/__init__.py

@@ -0,0 +1 @@
+"""Command modules for panqake git-stacking utility."""

panqake/commands/delete.py

@@ -0,0 +1,153 @@
+"""Command for deleting a branch and relinking the stack."""
+
+import sys
+
+from panqake.utils.config import (
+    add_to_stack,
+    get_child_branches,
+    get_parent_branch,
+    remove_from_stack,
+)
+from panqake.utils.git import branch_exists, get_current_branch, run_git_command
+from panqake.utils.questionary_prompt import (
+    format_branch,
+    print_formatted_text,
+    prompt_confirm,
+)
+
+
+def validate_branch_for_deletion(branch_name):
+    """Validate that a branch can be deleted."""
+    current_branch = get_current_branch()
+
+    # Check if target branch exists
+    if not branch_exists(branch_name):
+        print_formatted_text(
+            f"<warning>Error: Branch '{branch_name}' does not exist</warning>"
+        )
+        sys.exit(1)
+
+    # Check if target branch is the current branch
+    if branch_name == current_branch:
+        print_formatted_text(
+            "<warning>Error: Cannot delete the current branch. Please checkout another branch first.</warning>"
+        )
+        sys.exit(1)
+
+    return current_branch
+
+
+def get_branch_relationships(branch_name):
+    """Get parent and child branches and validate parent exists."""
+    parent_branch = get_parent_branch(branch_name)
+    child_branches = get_child_branches(branch_name)
+
+    # Ensure parent branch exists
+    if parent_branch and not branch_exists(parent_branch):
+        print_formatted_text(
+            f"<warning>Error: Parent branch '{parent_branch}' does not exist</warning>"
+        )
+        sys.exit(1)
+
+    return parent_branch, child_branches
+
+
+def display_deletion_info(branch_name, parent_branch, child_branches):
+    """Display deletion information and ask for confirmation."""
+    print_formatted_text(
+        f"<info>Branch to delete:</info> {format_branch(branch_name, danger=True)}"
+    )
+    if parent_branch:
+        print_formatted_text(
+            f"<info>Parent branch:</info> {format_branch(parent_branch)}"
+        )
+    if child_branches:
+        print_formatted_text("<info>Child branches that will be relinked:</info>")
+        for child in child_branches:
+            print_formatted_text(f"  {format_branch(child)}")
+
+    # Confirm deletion
+    if not prompt_confirm("Are you sure you want to delete this branch?"):
+        print_formatted_text("<info>Branch deletion cancelled.</info>")
+        return False
+
+    return True
+
+
+def relink_child_branches(child_branches, parent_branch, current_branch, branch_name):
+    """Relink child branches to the parent branch."""
+    if not child_branches:
+        return True
+
+    print_formatted_text(
+        f"<info>Relinking child branches to parent '{parent_branch}'...</info>"
+    )
+
+    for child in child_branches:
+        print_formatted_text(
+            f"<info>Processing child branch:</info> {format_branch(child)}"
+        )
+
+        # Checkout the child branch
+        checkout_result = run_git_command(["checkout", child])
+        if checkout_result is None:
+            print_formatted_text(
+                f"<warning>Error: Failed to checkout branch '{child}'</warning>"
+            )
+            run_git_command(["checkout", current_branch])
+            sys.exit(1)
+
+        # Rebase onto the grandparent branch
+        if parent_branch:
+            rebase_result = run_git_command(["rebase", parent_branch])
+            if rebase_result is None:
+                print_formatted_text(
+                    f"<warning>Error: Rebase conflict detected in branch '{child}'</warning>"
+                )
+                print_formatted_text(
+                    "<warning>Please resolve conflicts and run 'git rebase --continue'</warning>"
+                )
+                print_formatted_text(
+                    f"<warning>Then run 'panqake delete {branch_name}' again to retry</warning>"
+                )
+                sys.exit(1)
+
+            # Update stack metadata
+            add_to_stack(child, parent_branch)
+
+    return True
+
+
+def delete_branch(branch_name):
+    """Delete a branch and relink the stack."""
+    current_branch = validate_branch_for_deletion(branch_name)
+    parent_branch, child_branches = get_branch_relationships(branch_name)
+
+    if not display_deletion_info(branch_name, parent_branch, child_branches):
+        return
+
+    print_formatted_text(
+        f"<info>Deleting branch '{branch_name}' from the stack...</info>"
+    )
+
+    # Process child branches
+    relink_child_branches(child_branches, parent_branch, current_branch, branch_name)
+
+    # Return to original branch if it's not the one being deleted
+    if branch_name != current_branch:
+        run_git_command(["checkout", current_branch])
+
+    # Delete the branch
+    delete_result = run_git_command(["branch", "-D", branch_name])
+    if delete_result is None:
+        print_formatted_text(
+            f"<warning>Error: Failed to delete branch '{branch_name}'</warning>"
+        )
+        sys.exit(1)
+
+    # Remove from stack metadata
+    remove_from_stack(branch_name)
+
+    print_formatted_text(
+        f"<success>Success! Deleted branch '{branch_name}' and relinked the stack</success>"
+    )

panqake/commands/list.py

@@ -0,0 +1,74 @@
+"""Command for listing branches in the stack."""
+
+import sys
+
+from panqake.utils.config import get_child_branches, get_parent_branch
+from panqake.utils.git import branch_exists, get_current_branch
+
+
+def find_stack_root(branch):
+    """Find the root of the stack for a given branch."""
+    parent = get_parent_branch(branch)
+
+    if not parent:
+        return branch
+    else:
+        return find_stack_root(parent)
+
+
+def print_branch_tree(branch, indent="", is_last_sibling=True):
+    """Recursively print the branch tree."""
+    current_branch = get_current_branch()
+    is_current = branch == current_branch
+
+    # Determine the connector for the current branch
+    if indent:  # Not the root
+        connector = "└── " if is_last_sibling else "├── "
+    else:  # Root branch
+        connector = ""
+
+    # Format and print the current branch line
+    prefix = f"{indent}{connector}"
+    if is_current:
+        # Apply branch styling using ANSI codes
+        branch_display = f"* {branch}"
+        # Print prefix first, then styled branch with ANSI codes
+        print(f"{prefix}\033[92m{branch_display}\033[0m")
+    else:
+        # Non-current branches use default terminal text color
+        print(f"{prefix}{branch}")
+
+    # Prepare the indentation for children
+    # Add a vertical bar if this branch is not the last sibling, otherwise add spaces
+    child_indent = indent + ("    " if is_last_sibling else "│   ")
+
+    # Get children of this branch
+    children = get_child_branches(branch)
+    num_children = len(children)
+
+    if children:
+        for i, child in enumerate(children):
+            is_last_child = i == num_children - 1
+            print_branch_tree(child, child_indent, is_last_child)
+
+
+def list_branches(branch_name=None):
+    """List the branch stack."""
+    # If no branch specified, use current branch
+    if not branch_name:
+        branch_name = get_current_branch()
+
+    # Check if target branch exists
+    if not branch_exists(branch_name):
+        # Use standard print with ANSI codes for warning style (yellow)
+        print(f"\033[93mError: Branch '{branch_name}' does not exist\033[0m")
+        sys.exit(1)
+
+    # Find the root of the stack for the target branch
+    root_branch = find_stack_root(branch_name)
+
+    # Use standard print with ANSI codes for info style (cyan)
+    print(f"\033[96mBranch stack (current: {get_current_branch()})\033[0m")
+
+    # Initial call starts with no indent and assumes the root is the 'last sibling' conceptually
+    print_branch_tree(root_branch, indent="", is_last_sibling=True)

panqake/commands/new.py

@@ -0,0 +1,56 @@
+"""Command for creating a new branch in the stack."""
+
+import sys
+
+from panqake.utils.config import add_to_stack
+from panqake.utils.git import (
+    branch_exists,
+    get_current_branch,
+    list_all_branches,
+    run_git_command,
+)
+from panqake.utils.questionary_prompt import BranchNameValidator, prompt_input
+
+
+def create_new_branch(branch_name=None, base_branch=None):
+    """Create a new branch in the stack."""
+    # If no branch name specified, prompt for it
+    if not branch_name:
+        validator = BranchNameValidator()
+        branch_name = prompt_input("Enter new branch name: ", validator=validator)
+
+    # If no base branch specified, use current branch but offer selection
+    current = get_current_branch()
+    if not base_branch:
+        base_branch = current
+        branches = list_all_branches()
+        if branches:
+            base_branch = prompt_input(
+                f"Enter base branch [default: {current}]: ",
+                completer=branches,
+                default=current,
+            )
+
+    # Check if the new branch already exists
+    if branch_exists(branch_name):
+        print(f"Error: Branch '{branch_name}' already exists")
+        sys.exit(1)
+
+    # Check if the base branch exists
+    if base_branch and not branch_exists(base_branch):
+        print(f"Error: Base branch '{base_branch}' does not exist")
+        sys.exit(1)
+
+    print(f"Creating new branch '{branch_name}' based on '{base_branch}'...")
+
+    # Create the new branch
+    result = run_git_command(["checkout", "-b", branch_name, base_branch])
+    if result is None:
+        print("Error: Failed to create new branch")
+        sys.exit(1)
+
+    # Record the dependency information
+    add_to_stack(branch_name, base_branch)
+
+    print(f"Success! Created new branch '{branch_name}' in the stack")
+    print(f"Parent branch: {base_branch}")

panqake/commands/pr.py

@@ -0,0 +1,173 @@
+"""Command for creating pull requests for branches in the stack."""
+
+import shutil
+import subprocess
+import sys
+
+from panqake.utils.config import get_child_branches, get_parent_branch
+from panqake.utils.git import branch_exists, get_current_branch, run_git_command
+from panqake.utils.questionary_prompt import (
+    PRTitleValidator,
+    format_branch,
+    print_formatted_text,
+    prompt_confirm,
+    prompt_input,
+)
+
+
+def find_oldest_branch_without_pr(branch):
+    """Find the bottom-most branch without a PR."""
+    parent = get_parent_branch(branch)
+
+    # If no parent or parent is main/master, we've reached the bottom
+    if not parent or parent in ["main", "master"]:
+        return branch
+
+    # Check if parent branch already has a PR
+    if branch_has_pr(parent):
+        # Parent already has a PR, so this is the bottom-most branch without one
+        return branch
+    else:
+        # Parent doesn't have a PR, check further down the stack
+        return find_oldest_branch_without_pr(parent)
+
+
+def branch_has_pr(branch):
+    """Check if a branch already has a PR."""
+    try:
+        subprocess.run(
+            ["gh", "pr", "view", branch],
+            check=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        return True
+    except subprocess.CalledProcessError:
+        return False
+
+
+def create_pr_for_branch(branch, parent):
+    """Create a PR for a specific branch."""
+    # Get commit message for default PR title
+    commit_message = run_git_command(["log", "-1", "--pretty=%s", branch])
+    default_title = (
+        f"[{branch}] {commit_message}" if commit_message else f"[{branch}] Stacked PR"
+    )
+
+    # Prompt for PR details
+    title = prompt_input(
+        "Enter PR title: ", validator=PRTitleValidator(), default=default_title
+    )
+
+    description = prompt_input(
+        "Enter PR description (optional): ",
+        default="This is part of a stacked PR series.",
+    )
+
+    # Show summary and confirm
+    print_formatted_text(f"<info>PR for branch:</info> {format_branch(branch)}")
+    print_formatted_text(f"<info>Target branch:</info> {format_branch(parent)}")
+    print_formatted_text(f"<info>Title:</info> {title}")
+
+    if not prompt_confirm("Create this pull request?"):
+        print_formatted_text("<info>PR creation skipped.</info>")
+        return False
+
+    # Create the PR
+    try:
+        subprocess.run(
+            [
+                "gh",
+                "pr",
+                "create",
+                "--base",
+                parent,
+                "--head",
+                branch,
+                "--title",
+                title,
+                "--body",
+                description,
+            ],
+            check=True,
+        )
+        print_formatted_text(
+            f"<success>PR created successfully for {format_branch(branch)}</success>"
+        )
+        return True
+    except subprocess.CalledProcessError:
+        print_formatted_text(
+            f"<warning>Error: Failed to create PR for branch '{branch}'</warning>"
+        )
+        sys.exit(1)
+
+
+def is_branch_in_path_to_target(child, branch_name, parent_branch):
+    """Check if a child branch is in the path to the target branch."""
+    current = branch_name
+    while current and current != parent_branch:
+        if current == child:
+            return True
+        current = get_parent_branch(current)
+
+    return False
+
+
+def process_branch_for_pr(branch, target_branch):
+    """Process a branch to create PR and handle its children."""
+    if branch_has_pr(branch):
+        print_formatted_text(f"Branch {format_branch(branch)} already has an open PR")
+    else:
+        print_formatted_text(
+            f"<info>Creating PR for branch:</info> {format_branch(branch)}"
+        )
+
+        # Get parent branch for PR target
+        parent = get_parent_branch(branch)
+        if not parent:
+            parent = "main"  # Default to main if no parent
+
+        create_pr_for_branch(branch, parent)
+
+    # Process any children of this branch that lead to the target
+    for child in get_child_branches(branch):
+        if (
+            is_branch_in_path_to_target(child, target_branch, branch)
+            or child == target_branch
+        ):
+            process_branch_for_pr(child, target_branch)
+
+
+def create_pull_requests(branch_name=None):
+    """Create pull requests for branches in the stack."""
+    # Check for GitHub CLI
+    if not shutil.which("gh"):
+        print_formatted_text(
+            "<warning>Error: GitHub CLI (gh) is required but not installed.</warning>"
+        )
+        print_formatted_text(
+            "<info>Please install GitHub CLI: https://cli.github.com/manual/installation</info>"
+        )
+        sys.exit(1)
+
+    # If no branch specified, use current branch
+    if not branch_name:
+        branch_name = get_current_branch()
+
+    # Check if target branch exists
+    if not branch_exists(branch_name):
+        print_formatted_text(
+            f"<warning>Error: Branch '{branch_name}' does not exist</warning>"
+        )
+        sys.exit(1)
+
+    # Find the oldest branch in the stack that needs a PR
+    oldest_branch = find_oldest_branch_without_pr(branch_name)
+
+    print_formatted_text(
+        f"<info>Creating PRs from the bottom of the stack up to:</info> {format_branch(branch_name)}"
+    )
+
+    process_branch_for_pr(oldest_branch, branch_name)
+
+    print_formatted_text("<success>Pull request creation complete</success>")

panqake/commands/switch.py

@@ -0,0 +1,83 @@
+"""Command for switching between Git branches."""
+
+import sys
+
+import questionary
+
+from panqake.utils.git import get_current_branch, list_all_branches, run_git_command
+from panqake.utils.questionary_prompt import print_formatted_text
+
+
+def switch_branch(branch_name=None):
+    """Switch to another git branch using interactive selection.
+
+    Args:
+        branch_name: Optional branch name to switch to directly.
+                    If not provided, shows an interactive selection.
+    """
+    # Get all available branches
+    branches = list_all_branches()
+
+    if not branches:
+        print_formatted_text("<warning>No branches found in repository</warning>")
+        sys.exit(1)
+
+    current = get_current_branch()
+
+    # If branch name is provided, switch directly
+    if branch_name:
+        if branch_name not in branches:
+            print_formatted_text(
+                f"<warning>Error: Branch '{branch_name}' does not exist</warning>"
+            )
+            sys.exit(1)
+
+        if branch_name == current:
+            print_formatted_text(f"<info>Already on branch '{branch_name}'</info>")
+            return
+
+        _checkout_branch(branch_name)
+        return
+
+    # Format branches for display, marking the current branch
+    choices = []
+    for branch in branches:
+        is_current = branch == current
+        if is_current:
+            # Add a special marker for the current branch
+            choices.append(
+                questionary.Choice(
+                    title=f"* {branch} (current)",
+                    value=branch,
+                    disabled="current branch",
+                )
+            )
+        else:
+            choices.append(branch)
+
+    # Show interactive branch selection
+    selected = questionary.select(
+        "Select a branch to switch to:",
+        choices=choices,
+    ).ask()
+
+    if selected:
+        if selected == current:
+            print_formatted_text(f"<info>Already on branch '{selected}'</info>")
+            return
+
+        _checkout_branch(selected)
+
+
+def _checkout_branch(branch_name):
+    """Checkout to the specified branch."""
+    print_formatted_text(f"<info>Switching to branch '{branch_name}'...</info>")
+    result = run_git_command(["checkout", branch_name])
+
+    if result is not None:
+        print_formatted_text(
+            f"<success>Successfully switched to branch '{branch_name}'</success>"
+        )
+    else:
+        print_formatted_text("<danger>Failed to switch branches</danger>")
+        sys.exit(1)