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

titan_plugin_git/clients/git_client.py

@@ -109,6 +109,27 @@ class GitClient:
         """
         return self._run_command(["git", "rev-parse", "--abbrev-ref", "HEAD"])
 
+    def get_current_commit(self) -> str:
+        """
+        Get current commit SHA (HEAD)
+
+        Returns:
+            Full SHA of current commit
+        """
+        return self._run_command(["git", "rev-parse", "HEAD"])
+
+    def get_commit_sha(self, ref: str) -> str:
+        """
+        Get commit SHA for any git ref (branch, tag, remote branch, etc.)
+
+        Args:
+            ref: Git reference (e.g., "HEAD", "develop", "origin/main", "v1.0.0")
+
+        Returns:
+            Full SHA of the commit
+        """
+        return self._run_command(["git", "rev-parse", ref])
+
     def get_status(self) -> GitStatus:
         """
         Get repository status
@@ -282,13 +303,14 @@ class GitClient:
         """
         self._run_command(["git", "branch", branch_name, start_point])
 
-    def commit(self, message: str, all: bool = False) -> str:
+    def commit(self, message: str, all: bool = False, no_verify: bool = True) -> str:
         """
         Create a commit
 
         Args:
             message: Commit message
             all: Stage all modified and new files (`git add --all`)
+            no_verify: Skip pre-commit and commit-msg hooks
 
         Returns:
             Commit hash
@@ -298,6 +320,8 @@ class GitClient:
             self._run_command(["git", "add", "--all"])
 
         args = ["git", "commit", "-m", message]
+        if no_verify:
+            args.append("--no-verify")
         self._run_command(args)
 
         return self._run_command(["git", "rev-parse", "HEAD"])
@@ -347,7 +371,7 @@ class GitClient:
         self._run_command(["git", "branch", delete_arg, branch])
         return True
 
-    def push(self, remote: str = "origin", branch: Optional[str] = None, set_upstream: bool = False) -> None:
+    def push(self, remote: str = "origin", branch: Optional[str] = None, set_upstream: bool = False, tags: bool = False) -> None:
         """
         Push to remote
 
@@ -355,12 +379,16 @@ class GitClient:
             remote: Remote name
             branch: Branch to push (default: current)
             set_upstream: Set upstream tracking
+            tags: Push tags to remote (use --tags flag)
         """
         args = ["git", "push"]
 
         if set_upstream:
             args.append("-u")
-            
+
+        if tags:
+            args.append("--tags")
+
         args.append(remote)
 
         if branch:
@@ -383,12 +411,13 @@ class GitClient:
 
         self._run_command(args)
 
-    def fetch(self, remote: str = "origin", all: bool = False) -> None:
+    def fetch(self, remote: str = "origin", branch: Optional[str] = None, all: bool = False) -> None:
         """
         Fetch from remote
 
         Args:
             remote: Remote name
+            branch: Specific branch to fetch (optional)
             all: Fetch from all remotes
         """
         args = ["git", "fetch"]
@@ -397,6 +426,8 @@ class GitClient:
             args.append("--all")
         else:
             args.append(remote)
+            if branch:
+                args.append(branch)
 
         self._run_command(args)
 
@@ -729,6 +760,39 @@ class GitClient:
         except GitCommandError:
             return ""
 
+    def get_uncommitted_diff_stat(self) -> str:
+        """
+        Get diff stat summary of uncommitted changes (git diff --stat HEAD).
+
+        Returns a summary showing files changed, insertions, and deletions.
+
+        Returns:
+            Diff stat output as string
+        """
+        try:
+            return self._run_command(["git", "diff", "--stat", "HEAD"], check=False)
+        except GitCommandError:
+            return ""
+
+    def get_branch_diff_stat(self, base_branch: str, head_branch: str) -> str:
+        """
+        Get diff stat summary between two branches.
+
+        Args:
+            base_branch: Base branch name
+            head_branch: Head branch name
+
+        Returns:
+            Diff stat output as string
+        """
+        try:
+            return self._run_command(
+                ["git", "diff", "--stat", f"{base_branch}...{head_branch}"],
+                check=False
+            )
+        except GitCommandError:
+            return ""
+
     def get_branch_commits(self, base_branch: str, head_branch: str) -> list[str]:
         """
         Get list of commits in head_branch that are not in base_branch.
@@ -769,4 +833,75 @@ class GitClient:
         except GitCommandError:
             # Command failed, likely no remote 'origin' or not a git repo
             pass
-        return None, None
+        return None, None
+
+    def create_tag(self, tag_name: str, message: str, ref: str = "HEAD") -> None:
+        """
+        Create an annotated tag
+
+        Args:
+            tag_name: Name of the tag
+            message: Tag annotation message
+            ref: Reference to tag (default: HEAD)
+
+        Raises:
+            GitCommandError: If tag creation fails
+        """
+        self._run_command(["git", "tag", "-a", tag_name, "-m", message, ref])
+
+    def delete_tag(self, tag_name: str) -> None:
+        """
+        Delete a local tag
+
+        Args:
+            tag_name: Name of the tag to delete
+
+        Raises:
+            GitCommandError: If tag deletion fails
+        """
+        self._run_command(["git", "tag", "-d", tag_name])
+
+    def tag_exists(self, tag_name: str) -> bool:
+        """
+        Check if a tag exists locally
+
+        Args:
+            tag_name: Name of the tag to check
+
+        Returns:
+            True if tag exists, False otherwise
+        """
+        try:
+            self._run_command(["git", "tag", "-l", tag_name], check=False)
+            tags = self._run_command(["git", "tag", "-l", tag_name]).strip()
+            return tags == tag_name
+        except GitCommandError:
+            return False
+
+    def list_tags(self) -> List[str]:
+        """
+        List all tags in the repository
+
+        Returns:
+            List of tag names
+        """
+        try:
+            output = self._run_command(["git", "tag", "-l"])
+            if output.strip():
+                return [tag.strip() for tag in output.split('\n') if tag.strip()]
+            return []
+        except GitCommandError:
+            return []
+
+    def is_protected_branch(self, branch: str) -> bool:
+        """
+        Check if a branch is protected (main, master, develop, etc.)
+
+        Args:
+            branch: Branch name to check
+
+        Returns:
+            True if branch is protected
+        """
+        protected_branches = ["main", "master", "develop", "production", "staging"]
+        return branch.lower() in protected_branches

titan_plugin_git/plugin.py

@@ -100,6 +100,12 @@ class GitPlugin(TitanPlugin):
         """
         from .steps.branch_steps import get_current_branch_step, get_base_branch_step
         from .steps.ai_commit_message_step import ai_generate_commit_message
+        from .steps.diff_summary_step import show_uncommitted_diff_summary, show_branch_diff_summary
+        from .steps.save_current_branch_step import save_current_branch_step
+        from .steps.restore_original_branch_step import restore_original_branch_step
+        from .steps.checkout_step import checkout_branch_step
+        from .steps.pull_step import pull_step
+        from .steps.create_branch_step import create_branch_step
 
         return {
             "get_status": get_git_status_step,
@@ -108,6 +114,13 @@ class GitPlugin(TitanPlugin):
             "get_current_branch": get_current_branch_step,
             "get_base_branch": get_base_branch_step,
             "ai_generate_commit_message": ai_generate_commit_message,
+            "show_uncommitted_diff_summary": show_uncommitted_diff_summary,
+            "show_branch_diff_summary": show_branch_diff_summary,
+            "save_current_branch": save_current_branch_step,
+            "restore_original_branch": restore_original_branch_step,
+            "checkout": checkout_branch_step,
+            "pull": pull_step,
+            "create_branch": create_branch_step,
         }
 
     @property

titan_plugin_git/steps/ai_commit_message_step.py

@@ -1,7 +1,6 @@
 # plugins/titan-plugin-git/titan_plugin_git/steps/ai_commit_message_step.py
 from titan_cli.engine import WorkflowContext, WorkflowResult, Success, Error, Skip
 from titan_plugin_git.messages import msg
-from titan_cli.ui.tui.widgets import Panel
 
 
 def ai_generate_commit_message(ctx: WorkflowContext) -> WorkflowResult:
@@ -29,39 +28,36 @@ def ai_generate_commit_message(ctx: WorkflowContext) -> WorkflowResult:
     if not ctx.textual:
         return Error("Textual UI context is not available for this step.")
 
+    # Begin step container
+    ctx.textual.begin_step("AI Commit Message")
+
     # Check if AI is configured
     if not ctx.ai or not ctx.ai.is_available():
-        ctx.textual.mount(
-            Panel(
-                text=msg.Steps.AICommitMessage.AI_NOT_CONFIGURED,
-                panel_type="info"
-            )
-        )
+        ctx.textual.dim_text(msg.Steps.AICommitMessage.AI_NOT_CONFIGURED)
+        ctx.textual.end_step("skip")
         return Skip(msg.Steps.AICommitMessage.AI_NOT_CONFIGURED)
 
     # Get git client
     if not ctx.git:
+        ctx.textual.end_step("error")
         return Error(msg.Steps.AICommitMessage.GIT_CLIENT_NOT_AVAILABLE)
 
     # Get git status
     git_status = ctx.get('git_status')
     if not git_status or git_status.is_clean:
-        ctx.textual.mount(
-            Panel(
-                text=msg.Steps.AICommitMessage.NO_CHANGES_TO_COMMIT,
-                panel_type="info"
-            )
-        )
+        ctx.textual.dim_text(msg.Steps.AICommitMessage.NO_CHANGES_TO_COMMIT)
+        ctx.textual.end_step("skip")
         return Skip(msg.Steps.AICommitMessage.NO_CHANGES_TO_COMMIT)
 
     try:
         # Get diff of uncommitted changes
-        ctx.textual.text(msg.Steps.AICommitMessage.ANALYZING_CHANGES, markup="dim")
+        ctx.textual.dim_text(msg.Steps.AICommitMessage.ANALYZING_CHANGES)
 
         # Get diff of all uncommitted changes
         diff_text = ctx.git.get_uncommitted_diff()
 
         if not diff_text or diff_text.strip() == "":
+            ctx.textual.end_step("skip")
             return Skip(msg.Steps.AICommitMessage.NO_UNCOMMITTED_CHANGES)
 
         # Build AI prompt
@@ -86,17 +82,17 @@ def ai_generate_commit_message(ctx: WorkflowContext) -> WorkflowResult:
 
 ## CRITICAL Instructions
 Generate ONE single-line conventional commit message following this EXACT format:
-- type(scope): description
+- type(scope): Description
 - Types: feat, fix, refactor, docs, test, chore, style, perf
 - Scope: area affected (e.g., auth, api, ui)
-- Description: clear summary in imperative mood (be descriptive, concise, and at least 5 words long)
+- Description: clear summary in imperative mood, starting with CAPITAL letter (be descriptive, concise, and at least 5 words long)
 - NO line breaks, NO body, NO additional explanation
 
-Examples (notice they are all one line):
-- feat(auth): add OAuth2 integration with Google provider
-- fix(api): resolve race condition in cache invalidation
-- refactor(ui): simplify menu component and remove unused props
-- refactor(workflows): add support for nested workflow execution
+Examples (notice they start with capital letter and are all one line):
+- feat(auth): Add OAuth2 integration with Google provider
+- fix(api): Resolve race condition in cache invalidation
+- refactor(ui): Simplify menu component and remove unused props
+- refactor(workflows): Add support for nested workflow execution
 
 Return ONLY the single-line commit message, absolutely nothing else."""
 
@@ -115,14 +111,26 @@ Return ONLY the single-line commit message, absolutely nothing else."""
         # Take only the first line if AI returned multiple lines
         commit_message = commit_message.split('\n')[0].strip()
 
+        # Ensure subject starts with capital letter (conventional commits requirement)
+        # Format: type(scope): Description
+        if ':' in commit_message:
+            parts = commit_message.split(':', 1)
+            if len(parts) == 2:
+                prefix = parts[0]  # type(scope)
+                subject = parts[1].strip()  # description
+                # Capitalize first letter of subject
+                if subject and subject[0].islower():
+                    subject = subject[0].upper() + subject[1:]
+                commit_message = f"{prefix}: {subject}"
+
         # Show preview to user
         ctx.textual.text("")  # spacing
-        ctx.textual.text(msg.Steps.AICommitMessage.GENERATED_MESSAGE_TITLE, markup="bold")
-        ctx.textual.text(f"  {commit_message}", markup="bold cyan")
+        ctx.textual.bold_text(msg.Steps.AICommitMessage.GENERATED_MESSAGE_TITLE)
+        ctx.textual.bold_primary_text(f"  {commit_message}")
 
         # Warn if message is too long
         if len(commit_message) > 72:
-            ctx.textual.text(msg.Steps.AICommitMessage.MESSAGE_LENGTH_WARNING.format(length=len(commit_message)), markup="yellow")
+            ctx.textual.warning_text(msg.Steps.AICommitMessage.MESSAGE_LENGTH_WARNING.format(length=len(commit_message)))
 
         ctx.textual.text("")  # spacing
 
@@ -136,34 +144,31 @@ Return ONLY the single-line commit message, absolutely nothing else."""
             try:
                 manual_message = ctx.textual.ask_text(msg.Prompts.ENTER_COMMIT_MESSAGE)
                 if not manual_message:
+                    ctx.textual.end_step("error")
                     return Error(msg.Steps.Commit.COMMIT_MESSAGE_REQUIRED)
 
                 # Overwrite the metadata to ensure the manual message is used
+                ctx.textual.end_step("success")
                 return Success(
                     message=msg.Steps.Prompt.COMMIT_MESSAGE_CAPTURED,
                     metadata={"commit_message": manual_message}
                 )
             except (KeyboardInterrupt, EOFError):
+                ctx.textual.end_step("error")
                 return Error(msg.Steps.Prompt.USER_CANCELLED)
 
-        # Show success panel
-        ctx.textual.mount(
-            Panel(
-                text="AI commit message generated successfully",
-                panel_type="success"
-            )
-        )
-
         # Success - save to context
+        ctx.textual.end_step("success")
         return Success(
             msg.Steps.AICommitMessage.SUCCESS_MESSAGE,
             metadata={"commit_message": commit_message}
         )
 
     except Exception as e:
-        ctx.textual.text(msg.Steps.AICommitMessage.GENERATION_FAILED.format(e=e), markup="yellow")
-        ctx.textual.text(msg.Steps.AICommitMessage.FALLBACK_TO_MANUAL, markup="dim")
+        ctx.textual.warning_text(msg.Steps.AICommitMessage.GENERATION_FAILED.format(e=e))
+        ctx.textual.dim_text(msg.Steps.AICommitMessage.FALLBACK_TO_MANUAL)
 
+        ctx.textual.end_step("skip")
         return Skip(msg.Steps.AICommitMessage.GENERATION_FAILED.format(e=e))
 
 

titan_plugin_git/steps/branch_steps.py

@@ -1,6 +1,5 @@
 # plugins/titan-plugin-git/titan_plugin_git/steps/branch_steps.py
 from titan_cli.engine import WorkflowContext, WorkflowResult, Success, Error
-from titan_cli.ui.tui.widgets import Panel
 from titan_plugin_git.messages import msg
 
 def get_current_branch_step(ctx: WorkflowContext) -> WorkflowResult:
@@ -20,37 +19,28 @@ def get_current_branch_step(ctx: WorkflowContext) -> WorkflowResult:
     if not ctx.textual:
         return Error("Textual UI context is not available for this step.")
 
+    # Begin step container
+    ctx.textual.begin_step("Get Head Branch")
+
     if not ctx.git:
         error_msg = msg.Steps.Status.GIT_CLIENT_NOT_AVAILABLE
-        ctx.textual.mount(
-            Panel(
-                text=error_msg,
-                panel_type="error"
-            )
-        )
+        ctx.textual.error_text(error_msg)
+        ctx.textual.end_step("error")
         return Error(error_msg)
 
     try:
         current_branch = ctx.git.get_current_branch()
         success_msg = msg.Steps.Branch.GET_CURRENT_BRANCH_SUCCESS.format(branch=current_branch)
-        ctx.textual.mount(
-            Panel(
-                text=success_msg,
-                panel_type="success"
-            )
-        )
+        ctx.textual.success_text(success_msg)
+        ctx.textual.end_step("success")
         return Success(
             success_msg,
             metadata={"pr_head_branch": current_branch}
         )
     except Exception as e:
         error_msg = msg.Steps.Branch.GET_CURRENT_BRANCH_FAILED.format(e=e)
-        ctx.textual.mount(
-            Panel(
-                text=error_msg,
-                panel_type="error"
-            )
-        )
+        ctx.textual.error_text(error_msg)
+        ctx.textual.end_step("error")
         return Error(error_msg, exception=e)
 
 def get_base_branch_step(ctx: WorkflowContext) -> WorkflowResult:
@@ -70,35 +60,26 @@ def get_base_branch_step(ctx: WorkflowContext) -> WorkflowResult:
     if not ctx.textual:
         return Error("Textual UI context is not available for this step.")
 
+    # Begin step container
+    ctx.textual.begin_step("Get Base Branch")
+
     if not ctx.git:
         error_msg = msg.Steps.Status.GIT_CLIENT_NOT_AVAILABLE
-        ctx.textual.mount(
-            Panel(
-                text=error_msg,
-                panel_type="error"
-            )
-        )
+        ctx.textual.error_text(error_msg)
+        ctx.textual.end_step("error")
         return Error(error_msg)
 
     try:
         base_branch = ctx.git.main_branch
         success_msg = msg.Steps.Branch.GET_BASE_BRANCH_SUCCESS.format(branch=base_branch)
-        ctx.textual.mount(
-            Panel(
-                text=success_msg,
-                panel_type="success"
-            )
-        )
+        ctx.textual.success_text(success_msg)
+        ctx.textual.end_step("success")
         return Success(
             success_msg,
             metadata={"pr_base_branch": base_branch}
         )
     except Exception as e:
         error_msg = msg.Steps.Branch.GET_BASE_BRANCH_FAILED.format(e=e)
-        ctx.textual.mount(
-            Panel(
-                text=error_msg,
-                panel_type="error"
-            )
-        )
+        ctx.textual.error_text(error_msg)
+        ctx.textual.end_step("error")
         return Error(error_msg, exception=e)

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

@@ -3,7 +3,6 @@ from titan_cli.engine import WorkflowContext, WorkflowResult, Success, Error
 from titan_cli.engine.results import Skip
 from titan_plugin_git.exceptions import GitClientError, GitCommandError
 from titan_plugin_git.messages import msg
-from titan_cli.ui.tui.widgets import Panel
 
 
 def create_git_commit_step(ctx: WorkflowContext) -> WorkflowResult:
@@ -18,6 +17,7 @@ def create_git_commit_step(ctx: WorkflowContext) -> WorkflowResult:
         git_status (GitStatus): The git status object, used to check if the working directory is clean.
         commit_message (str): The message for the commit.
         all_files (bool, optional): Whether to commit all modified and new files. Defaults to True.
+        no_verify (bool, optional): Skip pre-commit and commit-msg hooks. Defaults to False.
         commit_hash (str, optional): If present, indicates a commit was already created.
 
     Outputs (saved to ctx.data):
@@ -31,50 +31,46 @@ def create_git_commit_step(ctx: WorkflowContext) -> WorkflowResult:
     if not ctx.textual:
         return Error("Textual UI context is not available for this step.")
 
+    # Begin step container
+    ctx.textual.begin_step("Create Commit")
+
     # Skip if there's nothing to commit
     git_status = ctx.data.get("git_status")
     if git_status and git_status.is_clean:
-        ctx.textual.mount(
-            Panel(
-                text=msg.Steps.Commit.WORKING_DIRECTORY_CLEAN,
-                panel_type="info"
-            )
-        )
+        ctx.textual.dim_text(msg.Steps.Commit.WORKING_DIRECTORY_CLEAN)
+        ctx.textual.end_step("skip")
         return Skip(msg.Steps.Commit.WORKING_DIRECTORY_CLEAN)
 
     if not ctx.git:
+        ctx.textual.end_step("error")
         return Error(msg.Steps.Commit.GIT_CLIENT_NOT_AVAILABLE)
 
     commit_message = ctx.get('commit_message')
     if not commit_message:
-        ctx.textual.mount(
-            Panel(
-                text=msg.Steps.Commit.NO_COMMIT_MESSAGE,
-                panel_type="info"
-            )
-        )
+        ctx.textual.dim_text(msg.Steps.Commit.NO_COMMIT_MESSAGE)
+        ctx.textual.end_step("skip")
         return Skip(msg.Steps.Commit.NO_COMMIT_MESSAGE)
-        
+
     all_files = ctx.get('all_files', True)
+    no_verify = ctx.get('no_verify', False)
 
     try:
-        commit_hash = ctx.git.commit(message=commit_message, all=all_files)
+        commit_hash = ctx.git.commit(message=commit_message, all=all_files, no_verify=no_verify)
 
-        # Show success panel
-        ctx.textual.mount(
-            Panel(
-                text=f"Commit created: {commit_hash[:7]}",
-                panel_type="success"
-            )
-        )
+        # Show success message
+        ctx.textual.success_text(f"Commit created: {commit_hash[:7]}")
 
+        ctx.textual.end_step("success")
         return Success(
             message=msg.Steps.Commit.COMMIT_SUCCESS.format(commit_hash=commit_hash),
             metadata={"commit_hash": commit_hash}
         )
     except GitClientError as e:
+        ctx.textual.end_step("error")
         return Error(msg.Steps.Commit.CLIENT_ERROR_DURING_COMMIT.format(e=e))
     except GitCommandError as e:
+        ctx.textual.end_step("error")
         return Error(msg.Steps.Commit.COMMAND_FAILED_DURING_COMMIT.format(e=e))
     except Exception as e:
+        ctx.textual.end_step("error")
         return Error(msg.Steps.Commit.UNEXPECTED_ERROR_DURING_COMMIT.format(e=e))