titan-cli 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

titan_plugin_git/steps/checkout_step.py

@@ -0,0 +1,66 @@
+"""
+Checkout a Git branch.
+"""
+
+from titan_cli.engine import WorkflowContext, WorkflowResult, Success, Error
+from titan_plugin_git.exceptions import GitError
+
+
+def checkout_branch_step(ctx: WorkflowContext) -> WorkflowResult:
+    """
+    Checkout a Git branch.
+
+    Inputs (from ctx.data):
+        branch (str): Branch name to checkout
+
+    Returns:
+        Success: Branch checked out successfully
+        Error: Git operation failed
+    """
+    if ctx.textual:
+        ctx.textual.begin_step("Checkout 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 branch from params, or use main_branch from git config
+        branch = ctx.get("branch")
+        if not branch:
+            branch = ctx.git.main_branch
+            ctx.textual.dim_text(f"Using main branch from config: {branch}")
+
+        ctx.textual.text("")
+        ctx.textual.dim_text(f"Checking out: {branch}")
+
+        # Checkout branch
+        try:
+            ctx.git.checkout(branch)
+            ctx.textual.success_text(f"✓ Checked out {branch}")
+        except GitError as e:
+            ctx.textual.text("")
+            ctx.textual.error_text(f"Failed to checkout {branch}: {str(e)}")
+            ctx.textual.end_step("error")
+            return Error(f"Failed to checkout: {str(e)}")
+
+        ctx.textual.text("")
+        ctx.textual.end_step("success")
+        return Success(
+            f"Checked out {branch}",
+            metadata={"branch": branch}
+        )
+
+    except Exception as e:
+        ctx.textual.text("")
+        ctx.textual.error_text(f"Failed to checkout branch: {str(e)}")
+        ctx.textual.text("")
+        ctx.textual.end_step("error")
+        return Error(f"Failed to checkout: {str(e)}")
+
+
+__all__ = ["checkout_branch_step"]

titan_plugin_git/steps/commit_step.py

@@ -37,7 +37,7 @@ def create_git_commit_step(ctx: WorkflowContext) -> WorkflowResult:
     # Skip if there's nothing to commit
     git_status = ctx.data.get("git_status")
     if git_status and git_status.is_clean:
-        ctx.textual.text(msg.Steps.Commit.WORKING_DIRECTORY_CLEAN, markup="dim")
+        ctx.textual.dim_text(msg.Steps.Commit.WORKING_DIRECTORY_CLEAN)
         ctx.textual.end_step("skip")
         return Skip(msg.Steps.Commit.WORKING_DIRECTORY_CLEAN)
 
@@ -47,7 +47,7 @@ def create_git_commit_step(ctx: WorkflowContext) -> WorkflowResult:
 
     commit_message = ctx.get('commit_message')
     if not commit_message:
-        ctx.textual.text(msg.Steps.Commit.NO_COMMIT_MESSAGE, markup="dim")
+        ctx.textual.dim_text(msg.Steps.Commit.NO_COMMIT_MESSAGE)
         ctx.textual.end_step("skip")
         return Skip(msg.Steps.Commit.NO_COMMIT_MESSAGE)
 
@@ -58,7 +58,7 @@ def create_git_commit_step(ctx: WorkflowContext) -> WorkflowResult:
         commit_hash = ctx.git.commit(message=commit_message, all=all_files, no_verify=no_verify)
 
         # Show success message
-        ctx.textual.text(f"Commit created: {commit_hash[:7]}", markup="green")
+        ctx.textual.success_text(f"Commit created: {commit_hash[:7]}")
 
         ctx.textual.end_step("success")
         return Success(

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

@@ -24,16 +24,16 @@ def show_uncommitted_diff_summary(ctx: WorkflowContext) -> WorkflowResult:
 
     try:
         # Get diff stat for uncommitted changes
-        stat_output = ctx.git._run_command(["git", "diff", "--stat", "HEAD"])
+        stat_output = ctx.git.get_uncommitted_diff_stat()
 
         if not stat_output or not stat_output.strip():
-            ctx.textual.text("No uncommitted changes to show", markup="dim")
+            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.text("Changes summary:", markup="bold")
+        ctx.textual.bold_text("Changes summary:")
         ctx.textual.text("")  # spacing
 
         # Parse lines to find max filename length for alignment
@@ -69,7 +69,7 @@ def show_uncommitted_diff_summary(ctx: WorkflowContext) -> WorkflowResult:
         for line in summary_lines:
             colored_line = line.replace('(+)', '[green](+)[/green]')
             colored_line = colored_line.replace('(-)', '[red](-)[/red]')
-            ctx.textual.text(f"  {colored_line}", markup="dim")
+            ctx.textual.dim_text(f"  {colored_line}")
 
         ctx.textual.text("")  # spacing
 
@@ -104,13 +104,13 @@ def show_branch_diff_summary(ctx: WorkflowContext) -> WorkflowResult:
     ctx.textual.begin_step("Show Branch Changes Summary")
 
     if not ctx.git:
-        ctx.textual.text(msg.Steps.Push.GIT_CLIENT_NOT_AVAILABLE, markup="red")
+        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.text("No head branch specified", markup="dim")
+        ctx.textual.dim_text("No head branch specified")
         ctx.textual.end_step("skip")
         return Skip("No head branch specified")
 
@@ -118,18 +118,16 @@ def show_branch_diff_summary(ctx: WorkflowContext) -> WorkflowResult:
 
     try:
         # Get diff stat between branches
-        stat_output = ctx.git._run_command([
-            "git", "diff", "--stat", f"{base_branch}...{head_branch}"
-        ])
+        stat_output = ctx.git.get_branch_diff_stat(base_branch, head_branch)
 
         if not stat_output or not stat_output.strip():
-            ctx.textual.text(f"No changes between {base_branch} and {head_branch}", markup="dim")
+            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.text(f"Changes in {head_branch} vs {base_branch}:", markup="bold")
+        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
@@ -165,7 +163,7 @@ def show_branch_diff_summary(ctx: WorkflowContext) -> WorkflowResult:
         for line in summary_lines:
             colored_line = line.replace('(+)', '[green](+)[/green]')
             colored_line = colored_line.replace('(-)', '[red](-)[/red]')
-            ctx.textual.text(f"  {colored_line}", markup="dim")
+            ctx.textual.dim_text(f"  {colored_line}")
 
         ctx.textual.text("")  # spacing
 
@@ -174,7 +172,7 @@ def show_branch_diff_summary(ctx: WorkflowContext) -> WorkflowResult:
 
     except Exception as e:
         # Don't fail the workflow, just skip
-        ctx.textual.text(f"Could not show branch diff summary: {e}", markup="yellow")
+        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}")
 

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

@@ -60,7 +60,7 @@ def create_git_push_step(ctx: WorkflowContext) -> WorkflowResult:
         if push_tags:
             success_msg += " (with tags)"
 
-        ctx.textual.text(success_msg, markup="green")
+        ctx.textual.success_text(success_msg)
 
         ctx.textual.end_step("success")
         return Success(
@@ -69,11 +69,11 @@ def create_git_push_step(ctx: WorkflowContext) -> WorkflowResult:
         )
     except GitCommandError as e:
         error_msg = msg.Steps.Push.PUSH_FAILED.format(e=e)
-        ctx.textual.text(error_msg, markup="red")
+        ctx.textual.error_text(error_msg)
         ctx.textual.end_step("error")
         return Error(error_msg)
     except Exception as e:
         error_msg = msg.Git.UNEXPECTED_ERROR.format(e=e)
-        ctx.textual.text(error_msg, markup="red")
+        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"]

titan_plugin_git/steps/status_step.py

@@ -3,7 +3,8 @@ from titan_cli.engine import (
     WorkflowContext,
     WorkflowResult,
     Success,
-    Error
+    Error,
+    Exit
 )
 from titan_cli.messages import msg as global_msg
 from ..messages import msg
@@ -12,6 +13,10 @@ def get_git_status_step(ctx: WorkflowContext) -> WorkflowResult:
     """
     Retrieves the current git status and saves it to the context.
 
+    Behavior:
+        - If there are uncommitted changes: Returns Success and continues workflow
+        - If working directory is clean: Returns Exit (stops workflow - nothing to commit)
+
     Requires:
         ctx.git: An initialized GitClient.
 
@@ -19,7 +24,8 @@ def get_git_status_step(ctx: WorkflowContext) -> WorkflowResult:
         git_status (GitStatus): The full git status object, which includes the `is_clean` flag.
 
     Returns:
-        Success: If the status was retrieved successfully.
+        Success: If there are changes to commit (workflow continues)
+        Exit: If working directory is clean (workflow stops - nothing to commit)
         Error: If the GitClient is not available or the git command fails.
     """
     if not ctx.textual:
@@ -34,22 +40,26 @@ def get_git_status_step(ctx: WorkflowContext) -> WorkflowResult:
     try:
         status = ctx.git.get_status()
 
-        # If there are uncommitted changes, show text (border will be green on success)
+        # If there are uncommitted changes, continue with workflow
         if not status.is_clean:
-            ctx.textual.text(global_msg.Workflow.UNCOMMITTED_CHANGES_WARNING, markup="yellow")
+            ctx.textual.warning_text(global_msg.Workflow.UNCOMMITTED_CHANGES_WARNING)
             message = msg.Steps.Status.STATUS_RETRIEVED_WITH_UNCOMMITTED
+            ctx.textual.end_step("success")
+
+            return Success(
+                message=message,
+                metadata={"git_status": status}
+            )
         else:
-            # Show text for clean working directory (border will be green)
-            ctx.textual.text(msg.Steps.Status.WORKING_DIRECTORY_IS_CLEAN, markup="green")
-            message = msg.Steps.Status.WORKING_DIRECTORY_IS_CLEAN
+            # Working directory is clean - exit workflow (nothing to commit)
+            ctx.textual.success_text(msg.Steps.Status.WORKING_DIRECTORY_IS_CLEAN)
+            ctx.textual.text("")
+            ctx.textual.dim_text("Nothing to commit. Skipping workflow.")
+            ctx.textual.end_step("success")
 
-        # End step container with success
-        ctx.textual.end_step("success")
+            # Exit workflow early (not an error)
+            return Exit("No changes to commit", metadata={"git_status": status})
 
-        return Success(
-            message=message,
-            metadata={"git_status": status}
-        )
     except Exception as e:
         # End step container with error
         ctx.textual.end_step("error")

titan_plugin_git/workflows/commit-ai.yaml

@@ -5,13 +5,14 @@ hooks:
   - before_commit  # Hook for linting/testing
 
 steps:
-  - hook: before_commit  # This is where injected steps will run
-
+  # Check for changes FIRST - exits workflow if nothing to commit
   - id: git_status
     name: "Check Git Status"
     plugin: git
     step: get_status
 
+  - hook: before_commit  # This is where injected steps will run
+
   - id: diff_summary
     name: "Show Changes Summary"
     plugin: git
@@ -26,7 +27,7 @@ steps:
     name: "Create Commit"
     plugin: git
     step: create_commit
-  
+
   - id: push
     name: "Push changes to remote"
     plugin: git