titan-cli 0.1.0__py3-none-any.whl

titan_plugin_git/exceptions.py

@@ -0,0 +1,40 @@
+"""
+Git Exceptions
+
+Custom exceptions for Git operations.
+"""
+
+
+class GitError(Exception):
+    """Base exception for Git errors"""
+    pass
+
+
+class GitCommandError(GitError):
+    """Git command failed"""
+    pass
+
+
+class GitClientError(GitError):
+    """Git client initialization or configuration error"""
+    pass
+
+
+class GitBranchNotFoundError(GitError):
+    """Branch not found"""
+    pass
+
+
+class GitDirtyWorkingTreeError(GitError):
+    """Working tree has uncommitted changes"""
+    pass
+
+
+class GitNotRepositoryError(GitError):
+    """Not a git repository"""
+    pass
+
+
+class GitMergeConflictError(GitError):
+    """Merge conflict occurred"""
+    pass

titan_plugin_git/messages.py

@@ -0,0 +1,112 @@
+
+class Messages:
+    class Prompts:
+        ENTER_COMMIT_MESSAGE: str = "Enter commit message:"
+
+    class Git:
+        """Git operations messages"""
+        CLI_NOT_FOUND: str = "Git CLI not found. Please install Git."
+        NOT_A_REPOSITORY: str = "'{repo_path}' is not a git repository"
+        COMMAND_FAILED: str = "Git command failed: {error_msg}"
+        UNEXPECTED_ERROR: str = "An unexpected error occurred: {e}"
+        UNCOMMITTED_CHANGES_OVERWRITE_KEYWORD: str = "would be overwritten"
+        CANNOT_CHECKOUT_UNCOMMITTED_CHANGES: str = "Cannot checkout: uncommitted changes would be overwritten"
+        MERGE_CONFLICT_KEYWORD: str = "Merge conflict"
+        MERGE_CONFLICT_WHILE_UPDATING: str = "Merge conflict while updating branch '{branch}'"
+        AUTO_STASH_MESSAGE: str = "titan-cli-auto-stash at {timestamp}"
+        CANNOT_CHECKOUT_UNCOMMITTED_CHANGES_EXIST: str = "Cannot checkout {branch}: uncommitted changes exist"
+        STASH_FAILED_BEFORE_CHECKOUT: str = "Failed to stash changes before checkout"
+        SAFE_SWITCH_STASH_MESSAGE: str = "titan-cli-safe-switch: from {current} to {branch}"
+        
+        # Commits
+        COMMITTING = "Committing changes..."
+        COMMIT_SUCCESS = "Committed: {sha}"
+        COMMIT_FAILED = "Commit failed: {error}"
+        NO_CHANGES = "No changes to commit"
+
+        # Branches
+        BRANCH_CREATING = "Creating branch: {name}"
+        BRANCH_CREATED = "Branch created: {name}"
+        BRANCH_SWITCHING = "Switching to branch: {name}"
+        BRANCH_SWITCHED = "Switched to branch: {name}"
+        BRANCH_DELETING = "Deleting branch: {name}"
+        BRANCH_DELETED = "Branch deleted: {name}"
+        BRANCH_EXISTS = "Branch already exists: {name}"
+        BRANCH_NOT_FOUND = "Branch not found: {name}"
+        BRANCH_INVALID_NAME = "Invalid branch name: {name}"
+        BRANCH_PROTECTED = "Cannot delete protected branch: {branch}"
+
+        # Push/Pull
+        PUSHING = "Pushing to remote..."
+        PUSH_SUCCESS = "Pushed to {remote}/{branch}"
+        PUSH_FAILED = "Push failed: {error}"
+        PULLING = "Pulling from remote..."
+        PULL_SUCCESS = "Pulled from {remote}/{branch}"
+        PULL_FAILED = "Pull failed: {error}"
+
+        # Status
+        STATUS_CLEAN = "Working directory clean"
+        STATUS_DIRTY = "Uncommitted changes detected"
+
+        # Repository
+        REPO_INIT = "Initializing git repository..."
+        REPO_INITIALIZED = "Git repository initialized"
+    
+    class Steps:
+        class Status:
+            GIT_CLIENT_NOT_AVAILABLE: str = "Git client is not available in the workflow context."
+            STATUS_RETRIEVED_SUCCESS: str = "Git status retrieved successfully."
+            STATUS_RETRIEVED_WITH_UNCOMMITTED: str = "Git status retrieved. Working directory is not clean."
+            WORKING_DIRECTORY_NOT_CLEAN: str = " Working directory is not clean."
+            WORKING_DIRECTORY_IS_CLEAN: str = "Git status retrieved. Working directory is clean."
+            FAILED_TO_GET_STATUS: str = "Failed to get git status: {e}"
+
+        class Commit:
+            GIT_CLIENT_NOT_AVAILABLE: str = "Git client is not available in the workflow context."
+            COMMIT_MESSAGE_REQUIRED: str = "Commit message cannot be empty."
+            COMMIT_SUCCESS: str = "Commit created successfully: {commit_hash}"
+            CLIENT_ERROR_DURING_COMMIT: str = "Git client error during commit: {e}"
+            COMMAND_FAILED_DURING_COMMIT: str = "Git command failed during commit: {e}"
+            UNEXPECTED_ERROR_DURING_COMMIT: str = "An unexpected error occurred during commit: {e}"
+            WORKING_DIRECTORY_CLEAN: str = "Working directory is clean, skipping commit."
+            NO_COMMIT_MESSAGE: str = "No commit message provided, skipping commit."
+
+        class Push:
+            GIT_CLIENT_NOT_AVAILABLE: str = "Git client is not available in the workflow context."
+            PUSH_FAILED: str = "Git push failed: {e}"
+
+        class Branch:
+            GET_CURRENT_BRANCH_SUCCESS: str = "Current branch is '{branch}'"
+            GET_CURRENT_BRANCH_FAILED: str = "Failed to get current branch: {e}"
+            GET_BASE_BRANCH_SUCCESS: str = "Base branch is '{branch}'"
+            GET_BASE_BRANCH_FAILED: str = "Failed to get base branch: {e}"
+
+        class Prompt:
+            WORKING_DIRECTORY_CLEAN: str = "Working directory is clean, no need for a commit message."
+            COMMIT_MESSAGE_CAPTURED: str = "Commit message captured"
+            USER_CANCELLED: str = "User cancelled."
+            PROMPT_FAILED: str = "Failed to prompt for commit message: {e}"
+
+        class AICommitMessage:
+            AI_NOT_CONFIGURED: str = "AI not configured. Run 'titan ai configure' to enable AI features."
+            NO_CHANGES_TO_COMMIT: str = "No changes to commit"
+            ANALYZING_CHANGES: str = "Analyzing uncommitted changes..."
+            NO_UNCOMMITTED_CHANGES: str = "No uncommitted changes to analyze"
+            DIFF_TRUNCATED: str = "... (diff truncated for brevity)"
+            GENERATING_MESSAGE: str = "Generating commit message with AI..."
+            GENERATED_MESSAGE_TITLE: str = "AI Generated Commit Message:"
+            MESSAGE_LENGTH_WARNING: str = "Message is {length} chars (recommended: ≤72)"
+            CONFIRM_USE_MESSAGE: str = "Use this commit message?"
+            USER_DECLINED: str = "User declined AI-generated commit message"
+            SUCCESS_MESSAGE: str = "AI generated commit message"
+            GENERATION_FAILED: str = "AI generation failed: {e}"
+            FALLBACK_TO_MANUAL: str = "Falling back to manual commit message..."
+            GIT_CLIENT_NOT_AVAILABLE: str = "Git client is not available in the workflow context."
+
+    class Plugin:
+        GIT_CLIENT_INIT_WARNING: str = "Warning: GitPlugin could not initialize GitClient: {e}"
+        GIT_CLIENT_NOT_AVAILABLE: str = "GitPlugin not initialized or Git CLI not available."
+
+
+
+msg = Messages()

titan_plugin_git/models.py

@@ -0,0 +1,39 @@
+"""
+Git Models
+
+Data models for Git operations.
+"""
+
+from dataclasses import dataclass
+from typing import Optional, List
+
+
+@dataclass
+class GitBranch:
+    """Git branch representation"""
+    name: str
+    is_current: bool = False
+    is_remote: bool = False
+    upstream: Optional[str] = None
+
+
+@dataclass
+class GitStatus:
+    """Git repository status"""
+    branch: str
+    is_clean: bool
+    modified_files: List[str]
+    untracked_files: List[str]
+    staged_files: List[str]
+    ahead: int = 0
+    behind: int = 0
+
+
+@dataclass
+class GitCommit:
+    """Git commit representation"""
+    hash: str
+    short_hash: str
+    message: str
+    author: str
+    date: str

titan_plugin_git/plugin.py

@@ -0,0 +1,118 @@
+# plugins/titan-plugin-git/titan_plugin_git/plugin.py
+import shutil
+from typing import Optional
+from pathlib import Path
+from titan_cli.core.plugins.models import GitPluginConfig
+from titan_cli.core.plugins.plugin_base import TitanPlugin
+from titan_cli.core.config import TitanConfig # Needed for type hinting
+from titan_cli.core.secrets import SecretManager # Needed for type hinting
+from .clients.git_client import GitClient
+from .exceptions import GitClientError
+from .messages import msg
+from .steps.status_step import get_git_status_step
+from .steps.commit_step import create_git_commit_step
+from .steps.push_step import create_git_push_step
+
+
+class GitPlugin(TitanPlugin):
+    """
+    Titan CLI Plugin for Git operations.
+    Provides a GitClient for interacting with the Git CLI.
+    """
+
+    @property
+    def name(self) -> str:
+        return "git"
+
+    @property
+    def description(self) -> str:
+        return "Provides core Git CLI functionalities."
+
+    @property
+    def dependencies(self) -> list[str]:
+        return []
+
+    def initialize(self, config: TitanConfig, secrets: SecretManager) -> None:
+        """
+        Initialize with configuration.
+        
+        Reads config from:
+            config.config.plugins["git"].config
+        """
+
+        # Get plugin-specific configuration data
+        plugin_config_data = self._get_plugin_config(config)
+
+        # Validate configuration using Pydantic model
+        validated_config = GitPluginConfig(**plugin_config_data)
+
+        # Initialize client with validated configuration
+        self._client = GitClient(
+            main_branch=validated_config.main_branch,
+            default_remote=validated_config.default_remote
+        )
+
+    def _get_plugin_config(self, config: TitanConfig) -> dict:
+        """
+        Extract plugin-specific configuration.
+        
+        Args:
+            config: TitanConfig instance
+        
+        Returns:
+            Plugin config dict (empty if not configured)
+        """
+        if "git" not in config.config.plugins:
+            return {}
+
+        plugin_entry = config.config.plugins["git"]
+        return plugin_entry.config if hasattr(plugin_entry, 'config') else {}
+
+    def get_config_schema(self) -> dict:
+        """
+        Return JSON schema for plugin configuration.
+        
+        Returns:
+            JSON schema dict
+        """
+        from titan_cli.core.plugins.models import GitPluginConfig
+        return GitPluginConfig.model_json_schema()
+
+
+    def is_available(self) -> bool:
+        """
+        Checks if the Git CLI is installed and available.
+        """
+        # Leverage the GitClient's own check
+        return shutil.which("git") is not None and hasattr(self, '_client') and self._client is not None
+
+    def get_client(self) -> GitClient:
+        """
+        Returns the initialized GitClient instance.
+        """
+        if not hasattr(self, '_client') or self._client is None:
+            raise GitClientError(msg.Plugin.git_client_not_available)
+        return self._client
+
+    def get_steps(self) -> dict:
+        """
+        Returns a dictionary of available workflow steps.
+        """
+        from .steps.branch_steps import get_current_branch_step, get_base_branch_step
+        from .steps.ai_commit_message_step import ai_generate_commit_message
+
+        return {
+            "get_status": get_git_status_step,
+            "create_commit": create_git_commit_step,
+            "push": create_git_push_step,
+            "get_current_branch": get_current_branch_step,
+            "get_base_branch": get_base_branch_step,
+            "ai_generate_commit_message": ai_generate_commit_message,
+        }
+
+    @property
+    def workflows_path(self) -> Optional[Path]:
+        """
+        Returns the path to the workflows directory for this plugin.
+        """
+        return Path(__file__).parent / "workflows"

titan_plugin_git/steps/__init__.py

@@ -0,0 +1 @@
+# This file makes the directory a Python package.

titan_plugin_git/steps/ai_commit_message_step.py

@@ -0,0 +1,171 @@
+# 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:
+    """
+    Generate a commit message using AI based on the current changes.
+
+    Uses AI to analyze the diff of uncommitted changes and generate a
+    conventional commit message (type(scope): description).
+
+    Requires:
+        ctx.git: An initialized GitClient.
+        ctx.ai: An initialized AIClient.
+
+    Inputs (from ctx.data):
+        git_status: Current git status with changes.
+
+    Outputs (saved to ctx.data):
+        commit_message (str): AI-generated commit message.
+
+    Returns:
+        Success: If the commit message was generated successfully.
+        Error: If the operation fails.
+        Skip: If no changes, AI not configured, or user declined.
+    """
+    if not ctx.textual:
+        return Error("Textual UI context is not available for this step.")
+
+    # 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"
+            )
+        )
+        return Skip(msg.Steps.AICommitMessage.AI_NOT_CONFIGURED)
+
+    # Get git client
+    if not ctx.git:
+        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"
+            )
+        )
+        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")
+
+        # Get diff of all uncommitted changes
+        diff_text = ctx.git.get_uncommitted_diff()
+
+        if not diff_text or diff_text.strip() == "":
+            return Skip(msg.Steps.AICommitMessage.NO_UNCOMMITTED_CHANGES)
+
+        # Build AI prompt
+        # Get list of modified files for the summary
+        all_files = git_status.modified_files + git_status.untracked_files + git_status.staged_files
+        files_summary = "\n".join([f"  - {f}" for f in all_files]) if all_files else "(checking diff)"
+
+        # Limit diff size to avoid token overflow (keep first 8000 chars)
+        diff_preview = diff_text[:8000] if len(diff_text) > 8000 else diff_text
+        if len(diff_text) > 8000:
+            diff_preview += f"\n\n{msg.Steps.AICommitMessage.DIFF_TRUNCATED}"
+
+        prompt = f"""Analyze these code changes and generate a conventional commit message.
+
+## Changed Files ({len(all_files)} total)
+{files_summary}
+
+## Diff
+```diff
+{diff_preview}
+```
+
+## CRITICAL Instructions
+Generate ONE single-line conventional commit message following this EXACT format:
+- 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)
+- 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
+
+Return ONLY the single-line commit message, absolutely nothing else."""
+
+        # Call AI with loading indicator
+        from titan_cli.ai.models import AIMessage
+
+        messages = [AIMessage(role="user", content=prompt)]
+
+        with ctx.textual.loading(msg.Steps.AICommitMessage.GENERATING_MESSAGE):
+            response = ctx.ai.generate(messages, max_tokens=1024, temperature=0.7)
+
+        commit_message = response.content.strip()
+
+        # Clean up the message (remove quotes, newlines, extra whitespace)
+        commit_message = commit_message.strip('"').strip("'").strip()
+        # Take only the first line if AI returned multiple lines
+        commit_message = commit_message.split('\n')[0].strip()
+
+        # 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")
+
+        # 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.text("")  # spacing
+
+        # Ask user if they want to use it
+        use_ai = ctx.textual.ask_confirm(
+            msg.Steps.AICommitMessage.CONFIRM_USE_MESSAGE,
+            default=True
+        )
+
+        if not use_ai:
+            try:
+                manual_message = ctx.textual.ask_text(msg.Prompts.ENTER_COMMIT_MESSAGE)
+                if not manual_message:
+                    return Error(msg.Steps.Commit.COMMIT_MESSAGE_REQUIRED)
+
+                # Overwrite the metadata to ensure the manual message is used
+                return Success(
+                    message=msg.Steps.Prompt.COMMIT_MESSAGE_CAPTURED,
+                    metadata={"commit_message": manual_message}
+                )
+            except (KeyboardInterrupt, EOFError):
+                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
+        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")
+
+        return Skip(msg.Steps.AICommitMessage.GENERATION_FAILED.format(e=e))
+
+
+# Export for plugin registration
+__all__ = ["ai_generate_commit_message"]

titan_plugin_git/steps/branch_steps.py

@@ -0,0 +1,104 @@
+# 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:
+    """
+    Retrieves the current git branch name and saves it to the context.
+
+    Requires:
+        ctx.git: An initialized GitClient.
+
+    Outputs (saved to ctx.data):
+        pr_head_branch (str): The name of the current branch, to be used as the head branch for a PR.
+
+    Returns:
+        Success: If the current branch was retrieved successfully.
+        Error: If the GitClient is not available or the git command fails.
+    """
+    if not ctx.textual:
+        return Error("Textual UI context is not available for this step.")
+
+    if not ctx.git:
+        error_msg = msg.Steps.Status.GIT_CLIENT_NOT_AVAILABLE
+        ctx.textual.mount(
+            Panel(
+                text=error_msg,
+                panel_type="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"
+            )
+        )
+        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"
+            )
+        )
+        return Error(error_msg, exception=e)
+
+def get_base_branch_step(ctx: WorkflowContext) -> WorkflowResult:
+    """
+    Retrieves the configured main/base branch name and saves it to the context.
+
+    Requires:
+        ctx.git: An initialized GitClient.
+
+    Outputs (saved to ctx.data):
+        pr_base_branch (str): The name of the base branch, to be used as the base branch for a PR.
+
+    Returns:
+        Success: If the base branch was retrieved successfully.
+        Error: If the GitClient is not available or the git command fails.
+    """
+    if not ctx.textual:
+        return Error("Textual UI context is not available for this step.")
+
+    if not ctx.git:
+        error_msg = msg.Steps.Status.GIT_CLIENT_NOT_AVAILABLE
+        ctx.textual.mount(
+            Panel(
+                text=error_msg,
+                panel_type="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"
+            )
+        )
+        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"
+            )
+        )
+        return Error(error_msg, exception=e)

titan_plugin_git/steps/commit_step.py

@@ -0,0 +1,80 @@
+# plugins/titan-plugin-git/titan_plugin_git/steps/commit_step.py
+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:
+    """
+    Creates a git commit.
+    Skips if the working directory is clean or if a commit was already created.
+
+    Requires:
+        ctx.git: An initialized GitClient.
+
+    Inputs (from ctx.data):
+        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.
+        commit_hash (str, optional): If present, indicates a commit was already created.
+
+    Outputs (saved to ctx.data):
+        commit_hash (str): The hash of the created commit.
+
+    Returns:
+        Success: If the commit was created successfully.
+        Error: If the GitClient is not available, or the commit operation fails.
+        Skip: If there are no changes to commit or a commit was already created.
+    """
+    if not ctx.textual:
+        return Error("Textual UI context is not available for this step.")
+
+    # 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"
+            )
+        )
+        return Skip(msg.Steps.Commit.WORKING_DIRECTORY_CLEAN)
+
+    if not ctx.git:
+        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"
+            )
+        )
+        return Skip(msg.Steps.Commit.NO_COMMIT_MESSAGE)
+        
+    all_files = ctx.get('all_files', True)
+
+    try:
+        commit_hash = ctx.git.commit(message=commit_message, all=all_files)
+
+        # Show success panel
+        ctx.textual.mount(
+            Panel(
+                text=f"Commit created: {commit_hash[:7]}",
+                panel_type="success"
+            )
+        )
+
+        return Success(
+            message=msg.Steps.Commit.COMMIT_SUCCESS.format(commit_hash=commit_hash),
+            metadata={"commit_hash": commit_hash}
+        )
+    except GitClientError as e:
+        return Error(msg.Steps.Commit.CLIENT_ERROR_DURING_COMMIT.format(e=e))
+    except GitCommandError as e:
+        return Error(msg.Steps.Commit.COMMAND_FAILED_DURING_COMMIT.format(e=e))
+    except Exception as e:
+        return Error(msg.Steps.Commit.UNEXPECTED_ERROR_DURING_COMMIT.format(e=e))