titan-cli 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

titan_plugin_git/steps/create_branch_step.py

@@ -0,0 +1,131 @@
+"""
+Create a new Git branch.
+"""
+
+from titan_cli.engine import WorkflowContext, WorkflowResult, Success, Error
+from titan_plugin_git.exceptions import GitError
+
+
+def create_branch_step(ctx: WorkflowContext) -> WorkflowResult:
+    """
+    Create a new Git branch.
+
+    Inputs (from ctx.data):
+        new_branch (str): Name of the branch to create
+        start_point (str, optional): Starting point for the branch (defaults to HEAD)
+        delete_if_exists (bool, optional): Delete the branch if it already exists (default: False)
+        checkout (bool, optional): Checkout the new branch after creation (default: True)
+
+    Returns:
+        Success: Branch created successfully
+        Error: Git operation failed
+    """
+    if ctx.textual:
+        ctx.textual.begin_step("Create Branch")
+
+    if not ctx.textual:
+        return Error("Textual UI context is not available for this step.")
+
+    if not ctx.git:
+        ctx.textual.error_text("Git client not available in context")
+        ctx.textual.end_step("error")
+        return Error("Git client not available in context")
+
+    try:
+        # Get params from context
+        new_branch = ctx.get("new_branch")
+        if not new_branch:
+            ctx.textual.error_text("No branch name specified")
+            ctx.textual.dim_text("Set 'new_branch' in workflow params or previous step")
+            ctx.textual.end_step("error")
+            return Error("No branch name specified")
+
+        start_point = ctx.get("start_point", "HEAD")
+        delete_if_exists = ctx.get("delete_if_exists", False)
+        checkout = ctx.get("checkout", True)
+
+        ctx.textual.text("")
+        ctx.textual.dim_text(f"Creating branch: {new_branch}")
+        ctx.textual.dim_text(f"From: {start_point}")
+
+        # Check if branch exists
+        all_branches = ctx.git.get_branches()
+        branch_names = [b.name for b in all_branches]
+        branch_exists = new_branch in branch_names
+
+        # Delete if exists and requested
+        if branch_exists and delete_if_exists:
+            ctx.textual.text("")
+            ctx.textual.warning_text(f"Branch {new_branch} exists, deleting...")
+
+            # If we're on the branch, checkout another one first
+            current_branch = ctx.git.get_current_branch()
+            if current_branch == new_branch:
+                # Checkout main branch before deleting
+                main_branch = ctx.git.main_branch
+                if main_branch in branch_names and main_branch != new_branch:
+                    try:
+                        ctx.git.checkout(main_branch)
+                        ctx.textual.dim_text(f"Switched to {main_branch}")
+                    except GitError as e:
+                        ctx.textual.error_text(f"Failed to checkout {main_branch}: {str(e)}")
+                        ctx.textual.end_step("error")
+                        return Error(f"Cannot checkout {main_branch}: {str(e)}")
+                else:
+                    ctx.textual.error_text(f"Cannot delete current branch {new_branch}")
+                    ctx.textual.end_step("error")
+                    return Error("Cannot delete current branch")
+
+            # Delete the branch
+            try:
+                ctx.git.safe_delete_branch(new_branch, force=True)
+                ctx.textual.success_text(f"✓ Deleted existing branch {new_branch}")
+            except GitError as e:
+                ctx.textual.error_text(f"Failed to delete {new_branch}: {str(e)}")
+                ctx.textual.end_step("error")
+                return Error(f"Failed to delete branch: {str(e)}")
+
+        elif branch_exists:
+            ctx.textual.error_text(f"Branch {new_branch} already exists")
+            ctx.textual.dim_text("Set 'delete_if_exists: true' to recreate it")
+            ctx.textual.end_step("error")
+            return Error(f"Branch {new_branch} already exists")
+
+        # Create the branch
+        ctx.textual.text("")
+        try:
+            ctx.git.create_branch(new_branch, start_point=start_point)
+            ctx.textual.success_text(f"✓ Created branch {new_branch}")
+        except GitError as e:
+            ctx.textual.error_text(f"Failed to create {new_branch}: {str(e)}")
+            ctx.textual.end_step("error")
+            return Error(f"Failed to create branch: {str(e)}")
+
+        # Checkout if requested
+        if checkout:
+            try:
+                ctx.git.checkout(new_branch)
+                ctx.textual.success_text(f"✓ Checked out {new_branch}")
+            except GitError as e:
+                ctx.textual.warning_text(f"Branch created but failed to checkout: {str(e)}")
+
+        ctx.textual.text("")
+        ctx.textual.end_step("success")
+        return Success(
+            f"Created branch {new_branch}",
+            metadata={
+                "new_branch": new_branch,
+                "start_point": start_point,
+                "checked_out": checkout
+            }
+        )
+
+    except Exception as e:
+        ctx.textual.text("")
+        ctx.textual.error_text(f"Failed to create branch: {str(e)}")
+        ctx.textual.text("")
+        ctx.textual.end_step("error")
+        return Error(f"Failed to create branch: {str(e)}")
+
+
+__all__ = ["create_branch_step"]

titan_plugin_git/steps/diff_summary_step.py

@@ -0,0 +1,180 @@
+# plugins/titan-plugin-git/titan_plugin_git/steps/diff_summary_step.py
+from titan_cli.engine import WorkflowContext, WorkflowResult, Success, Error, Skip
+from titan_plugin_git.messages import msg
+
+
+def show_uncommitted_diff_summary(ctx: WorkflowContext) -> WorkflowResult:
+    """
+    Show summary of uncommitted changes (git diff --stat).
+
+    Provides a visual overview of files changed and lines modified
+    before generating commit messages.
+
+    Returns:
+        Success: Always (even if no changes, for workflow continuity)
+    """
+    if not ctx.textual:
+        return Error("Textual UI context is not available for this step.")
+
+    if not ctx.git:
+        return Error(msg.Steps.Push.GIT_CLIENT_NOT_AVAILABLE)
+
+    # Begin step container
+    ctx.textual.begin_step("Show Changes Summary")
+
+    try:
+        # Get diff stat for uncommitted changes
+        stat_output = ctx.git.get_uncommitted_diff_stat()
+
+        if not stat_output or not stat_output.strip():
+            ctx.textual.dim_text("No uncommitted changes to show")
+            ctx.textual.end_step("success")
+            return Success("No changes")
+
+        # Show the stat summary with colors
+        ctx.textual.text("")  # spacing
+        ctx.textual.bold_text("Changes summary:")
+        ctx.textual.text("")  # spacing
+
+        # Parse lines to find max filename length for alignment
+        file_lines = []
+        summary_lines = []
+        max_filename_len = 0
+
+        for line in stat_output.split('\n'):
+            if not line.strip():
+                continue
+
+            if '|' in line:
+                parts = line.split('|')
+                filename = parts[0].strip()
+                stats = '|'.join(parts[1:]) if len(parts) > 1 else ''
+                file_lines.append((filename, stats))
+                max_filename_len = max(max_filename_len, len(filename))
+            else:
+                summary_lines.append(line)
+
+        # Display aligned file changes
+        for filename, stats in file_lines:
+            # Pad filename to align pipes
+            padded_filename = filename.ljust(max_filename_len)
+
+            # Replace + with green and - with red
+            stats = stats.replace('+', '[green]+[/green]')
+            stats = stats.replace('-', '[red]-[/red]')
+
+            ctx.textual.text(f"  {padded_filename} | {stats}")
+
+        # Display summary lines
+        for line in summary_lines:
+            colored_line = line.replace('(+)', '[green](+)[/green]')
+            colored_line = colored_line.replace('(-)', '[red](-)[/red]')
+            ctx.textual.dim_text(f"  {colored_line}")
+
+        ctx.textual.text("")  # spacing
+
+        # End step container with success
+        ctx.textual.end_step("success")
+
+        return Success("Diff summary displayed")
+
+    except Exception as e:
+        # Don't fail the workflow, just skip
+        ctx.textual.end_step("skip")
+        return Skip(f"Could not show diff summary: {e}")
+
+
+def show_branch_diff_summary(ctx: WorkflowContext) -> WorkflowResult:
+    """
+    Show summary of branch changes (git diff base...head --stat).
+
+    Provides a visual overview of files changed between branches
+    before generating PR descriptions.
+
+    Inputs (from ctx.data):
+        pr_head_branch (str): Head branch name
+
+    Returns:
+        Success: Always (even if no changes, for workflow continuity)
+    """
+    if not ctx.textual:
+        return Error("Textual UI context is not available for this step.")
+
+    # Begin step container
+    ctx.textual.begin_step("Show Branch Changes Summary")
+
+    if not ctx.git:
+        ctx.textual.error_text(msg.Steps.Push.GIT_CLIENT_NOT_AVAILABLE)
+        ctx.textual.end_step("error")
+        return Error(msg.Steps.Push.GIT_CLIENT_NOT_AVAILABLE)
+
+    head_branch = ctx.get("pr_head_branch")
+    if not head_branch:
+        ctx.textual.dim_text("No head branch specified")
+        ctx.textual.end_step("skip")
+        return Skip("No head branch specified")
+
+    base_branch = ctx.git.main_branch
+
+    try:
+        # Get diff stat between branches
+        stat_output = ctx.git.get_branch_diff_stat(base_branch, head_branch)
+
+        if not stat_output or not stat_output.strip():
+            ctx.textual.dim_text(f"No changes between {base_branch} and {head_branch}")
+            ctx.textual.end_step("success")
+            return Success("No changes")
+
+        # Show the stat summary with colors
+        ctx.textual.text("")  # spacing
+        ctx.textual.bold_text(f"Changes in {head_branch} vs {base_branch}:")
+        ctx.textual.text("")  # spacing
+
+        # Parse lines to find max filename length for alignment
+        file_lines = []
+        summary_lines = []
+        max_filename_len = 0
+
+        for line in stat_output.split('\n'):
+            if not line.strip():
+                continue
+
+            if '|' in line:
+                parts = line.split('|')
+                filename = parts[0].strip()
+                stats = '|'.join(parts[1:]) if len(parts) > 1 else ''
+                file_lines.append((filename, stats))
+                max_filename_len = max(max_filename_len, len(filename))
+            else:
+                summary_lines.append(line)
+
+        # Display aligned file changes
+        for filename, stats in file_lines:
+            # Pad filename to align pipes
+            padded_filename = filename.ljust(max_filename_len)
+
+            # Replace + with green and - with red
+            stats = stats.replace('+', '[green]+[/green]')
+            stats = stats.replace('-', '[red]-[/red]')
+
+            ctx.textual.text(f"  {padded_filename} | {stats}")
+
+        # Display summary lines
+        for line in summary_lines:
+            colored_line = line.replace('(+)', '[green](+)[/green]')
+            colored_line = colored_line.replace('(-)', '[red](-)[/red]')
+            ctx.textual.dim_text(f"  {colored_line}")
+
+        ctx.textual.text("")  # spacing
+
+        ctx.textual.end_step("success")
+        return Success("Branch diff summary displayed")
+
+    except Exception as e:
+        # Don't fail the workflow, just skip
+        ctx.textual.warning_text(f"Could not show branch diff summary: {e}")
+        ctx.textual.end_step("skip")
+        return Skip(f"Could not show branch diff summary: {e}")
+
+
+__all__ = ["show_uncommitted_diff_summary", "show_branch_diff_summary"]

titan_plugin_git/steps/pull_step.py

@@ -0,0 +1,70 @@
+"""
+Pull from Git remote.
+"""
+
+from typing import Optional
+from titan_cli.engine import WorkflowContext, WorkflowResult, Success, Error
+from titan_plugin_git.exceptions import GitError
+
+
+def pull_step(ctx: WorkflowContext) -> WorkflowResult:
+    """
+    Pull from Git remote.
+
+    Inputs (from ctx.data):
+        remote (str, optional): Remote name (defaults to "origin")
+        branch (str, optional): Branch name (defaults to current branch)
+
+    Returns:
+        Success: Pull completed successfully
+        Error: Git operation failed
+    """
+    if ctx.textual:
+        ctx.textual.begin_step("Pull from Remote")
+
+    if not ctx.textual:
+        return Error("Textual UI context is not available for this step.")
+
+    if not ctx.git:
+        ctx.textual.error_text("Git client not available in context")
+        ctx.textual.end_step("error")
+        return Error("Git client not available in context")
+
+    try:
+        # Get params from context (optional)
+        remote = ctx.get("remote", "origin")
+        branch: Optional[str] = ctx.get("pull_branch")  # Optional, defaults to current
+
+        ctx.textual.text("")
+        if branch:
+            ctx.textual.dim_text(f"Pulling {remote}/{branch}...")
+        else:
+            ctx.textual.dim_text(f"Pulling from {remote}...")
+
+        # Pull
+        try:
+            with ctx.textual.loading("Pulling from remote..."):
+                ctx.git.pull(remote=remote, branch=branch)
+            ctx.textual.success_text(f"✓ Pulled from {remote}")
+        except GitError as e:
+            ctx.textual.text("")
+            ctx.textual.error_text(f"Failed to pull: {str(e)}")
+            ctx.textual.end_step("error")
+            return Error(f"Failed to pull: {str(e)}")
+
+        ctx.textual.text("")
+        ctx.textual.end_step("success")
+        return Success(
+            f"Pulled from {remote}",
+            metadata={"remote": remote, "branch": branch}
+        )
+
+    except Exception as e:
+        ctx.textual.text("")
+        ctx.textual.error_text(f"Failed to pull: {str(e)}")
+        ctx.textual.text("")
+        ctx.textual.end_step("error")
+        return Error(f"Failed to pull: {str(e)}")
+
+
+__all__ = ["pull_step"]

titan_plugin_git/steps/push_step.py

@@ -2,7 +2,6 @@
 from titan_cli.engine import WorkflowContext, WorkflowResult, Success, Error
 from titan_plugin_git.exceptions import GitCommandError
 from titan_plugin_git.messages import msg
-from titan_cli.ui.tui.widgets import Panel
 
 def create_git_push_step(ctx: WorkflowContext) -> WorkflowResult:
     """
@@ -12,6 +11,7 @@ def create_git_push_step(ctx: WorkflowContext) -> WorkflowResult:
         remote (str, optional): The name of the remote to push to. Defaults to the client's default remote.
         branch (str, optional): The name of the branch to push. Defaults to the current branch.
         set_upstream (bool, optional): Whether to set the upstream tracking branch. Defaults to False.
+        push_tags (bool, optional): Whether to push tags along with the branch. Defaults to False.
 
     Requires:
         ctx.git: An initialized GitClient.
@@ -29,10 +29,14 @@ def create_git_push_step(ctx: WorkflowContext) -> WorkflowResult:
     if not ctx.git:
         return Error(msg.Steps.Push.GIT_CLIENT_NOT_AVAILABLE)
 
+    # Begin step container
+    ctx.textual.begin_step("Push changes to remote")
+
     # Get params from context
     remote = ctx.get('remote')
     branch = ctx.get('branch')
     set_upstream = ctx.get('set_upstream', False)
+    push_tags = ctx.get('push_tags', False)
 
     # Use defaults from the GitClient if not provided in the context
     remote_to_use = remote or ctx.git.default_remote
@@ -43,21 +47,33 @@ def create_git_push_step(ctx: WorkflowContext) -> WorkflowResult:
         if not ctx.git.branch_exists_on_remote(branch=branch_to_use, remote=remote_to_use):
             set_upstream = True
 
-        ctx.git.push(remote=remote_to_use, branch=branch_to_use, set_upstream=set_upstream)
-
-        # Show success panel
-        ctx.textual.mount(
-            Panel(
-                text=f"Pushed to {remote_to_use}/{branch_to_use}",
-                panel_type="success"
-            )
+        # Push branch (and tags if requested)
+        ctx.git.push(
+            remote=remote_to_use,
+            branch=branch_to_use,
+            set_upstream=set_upstream,
+            tags=push_tags
         )
 
+        # Show success message
+        success_msg = f"Pushed to {remote_to_use}/{branch_to_use}"
+        if push_tags:
+            success_msg += " (with tags)"
+
+        ctx.textual.success_text(success_msg)
+
+        ctx.textual.end_step("success")
         return Success(
             message=msg.Git.PUSH_SUCCESS.format(remote=remote_to_use, branch=branch_to_use),
             metadata={"pr_head_branch": branch_to_use}
         )
     except GitCommandError as e:
-        return Error(msg.Steps.Push.PUSH_FAILED.format(e=e))
+        error_msg = msg.Steps.Push.PUSH_FAILED.format(e=e)
+        ctx.textual.error_text(error_msg)
+        ctx.textual.end_step("error")
+        return Error(error_msg)
     except Exception as e:
-        return Error(msg.Git.UNEXPECTED_ERROR.format(e=e))
+        error_msg = msg.Git.UNEXPECTED_ERROR.format(e=e)
+        ctx.textual.error_text(error_msg)
+        ctx.textual.end_step("error")
+        return Error(error_msg)

titan_plugin_git/steps/restore_original_branch_step.py

@@ -0,0 +1,97 @@
+"""
+Restore original branch and pop stashed changes.
+"""
+
+from titan_cli.engine import WorkflowContext, WorkflowResult, Success, Error
+from titan_plugin_git.exceptions import GitError
+
+
+def restore_original_branch_step(ctx: WorkflowContext) -> WorkflowResult:
+    """
+    Restore original branch and pop stashed changes.
+
+    Returns the user to their original branch and restores any changes
+    that were stashed at the beginning of the workflow.
+
+    This step ALWAYS executes, even if the workflow failed.
+
+    Inputs (from ctx.data):
+        original_branch (str): Name of the branch to restore
+        has_stashed_changes (bool): Whether to pop stashed changes
+
+    Returns:
+        Success: Branch restored and changes popped if needed
+        Error: Git operation failed
+    """
+    if ctx.textual:
+        ctx.textual.begin_step("Restore Original Branch")
+
+    if not ctx.textual:
+        return Error("Textual UI context is not available for this step.")
+
+    if not ctx.git:
+        ctx.textual.error_text("Git client not available in context")
+        ctx.textual.end_step("error")
+        return Error("Git client not available in context")
+
+    try:
+        # Get original branch from context
+        original_branch = ctx.get("original_branch")
+        has_stashed_changes = ctx.get("has_stashed_changes", False)
+
+        if not original_branch:
+            ctx.textual.warning_text("No original branch to restore")
+            ctx.textual.end_step("success")
+            return Success("No branch to restore")
+
+        ctx.textual.text("")
+        ctx.textual.dim_text(f"Returning to: {original_branch}")
+
+        # Checkout original branch
+        try:
+            ctx.git.checkout(original_branch)
+            ctx.textual.success_text(f"✓ Checked out {original_branch}")
+        except GitError as e:
+            ctx.textual.error_text(f"Failed to checkout {original_branch}: {str(e)}")
+            ctx.textual.end_step("error")
+            return Error(f"Failed to checkout: {str(e)}")
+
+        # Pop stashed changes if any
+        if has_stashed_changes:
+            ctx.textual.text("")
+            ctx.textual.dim_text("Restoring stashed changes...")
+
+            with ctx.textual.loading("Popping stashed changes..."):
+                success = ctx.git.stash_pop()
+
+            if not success:
+                ctx.textual.warning_text("Failed to pop stash automatically")
+                ctx.textual.dim_text("Run: git stash pop")
+                # Don't fail the step, just warn
+            else:
+                ctx.textual.success_text("✓ Changes restored")
+
+        ctx.textual.text("")
+        ctx.textual.end_step("success")
+        return Success(
+            f"Restored to {original_branch}",
+            metadata={
+                "original_branch": original_branch,
+                "stash_popped": has_stashed_changes
+            }
+        )
+
+    except Exception as e:
+        ctx.textual.text("")
+        ctx.textual.error_text(f"Failed to restore original branch: {str(e)}")
+        ctx.textual.dim_text("You may need to manually restore your branch:")
+        if ctx.get("original_branch"):
+            ctx.textual.dim_text(f"  git checkout {ctx.get('original_branch')}")
+        if ctx.get("has_stashed_changes"):
+            ctx.textual.dim_text("  git stash pop")
+        ctx.textual.text("")
+        ctx.textual.end_step("error")
+        return Error(f"Failed to restore: {str(e)}")
+
+
+__all__ = ["restore_original_branch_step"]

titan_plugin_git/steps/save_current_branch_step.py

@@ -0,0 +1,82 @@
+"""
+Save current branch and stash uncommitted changes.
+"""
+
+from titan_cli.engine import WorkflowContext, WorkflowResult, Success, Error
+
+
+def save_current_branch_step(ctx: WorkflowContext) -> WorkflowResult:
+    """
+    Save current branch and stash uncommitted changes.
+
+    This allows the workflow to create release notes in a separate branch
+    without affecting the user's current work.
+
+    Outputs (saved to ctx.data):
+        original_branch (str): Name of the branch the user was on
+        has_stashed_changes (bool): Whether changes were stashed
+
+    Returns:
+        Success: Branch saved and changes stashed if needed
+        Error: Git operation failed
+    """
+    if ctx.textual:
+        ctx.textual.begin_step("Save Current Branch")
+
+    if not ctx.textual:
+        return Error("Textual UI context is not available for this step.")
+
+    if not ctx.git:
+        ctx.textual.error_text("Git client not available in context")
+        ctx.textual.end_step("error")
+        return Error("Git client not available in context")
+
+    try:
+        # Get current branch
+        current_branch = ctx.git.get_current_branch()
+        ctx.set("original_branch", current_branch)
+
+        ctx.textual.text("")
+        ctx.textual.dim_text(f"Current branch: {current_branch}")
+
+        # Check for uncommitted changes
+        has_changes = ctx.git.has_uncommitted_changes()
+
+        if has_changes:
+            ctx.textual.dim_text("Uncommitted changes detected")
+            ctx.textual.text("")
+
+            # Stash changes
+            with ctx.textual.loading("Stashing uncommitted changes..."):
+                success = ctx.git.stash_push(message="titan-release-notes-workflow")
+
+            if not success:
+                ctx.textual.error_text("Failed to stash changes")
+                ctx.textual.end_step("error")
+                return Error("Failed to stash changes")
+
+            ctx.set("has_stashed_changes", True)
+            ctx.textual.success_text("✓ Changes stashed successfully")
+        else:
+            ctx.textual.dim_text("No uncommitted changes")
+            ctx.set("has_stashed_changes", False)
+
+        ctx.textual.text("")
+        ctx.textual.end_step("success")
+        return Success(
+            f"Saved branch: {current_branch}",
+            metadata={
+                "original_branch": current_branch,
+                "has_stashed_changes": has_changes
+            }
+        )
+
+    except Exception as e:
+        ctx.textual.text("")
+        ctx.textual.error_text(f"Failed to save current branch: {str(e)}")
+        ctx.textual.text("")
+        ctx.textual.end_step("error")
+        return Error(f"Failed to save current branch: {str(e)}")
+
+
+__all__ = ["save_current_branch_step"]