✨ feat: enhance commit process with CLI options

Test User · Test User · commit d0457dbfa2e8 · 2024-12-09T10:24:00.000+01:00
✨ feat: enhance commit process with CLI options

✨ Features:
- Introduced CLI options for auto-commit, combining commits, and enabling debug logging
- Implemented main command function using Click for better CLI interaction
- Refactored commit processing logic to support batch processing

📜 Logging:
- Added logging setup with Rich for improved output formatting
- Implemented debug logging for better traceability during execution

🔧 Dependencies:
- Updated dependencies to include Click for CLI functionality

Enhanced commit process with new CLI options and improved logging
diff --git a/commitloom/__main__.py b/commitloom/__main__.py
@@ -4,13 +4,25 @@
 
 import os
 
+import click
 from dotenv import load_dotenv
 
 # Load environment variables before any imports
 env_path = os.path.join(os.path.dirname(__file__), "..", ".env")
 load_dotenv(dotenv_path=env_path)
 
-from .cli.main import main
+from .cli.main import CommitLoom
+
+
+@click.command()
+@click.option("-y", "--yes", is_flag=True, help="Skip all confirmation prompts")
+@click.option("-c", "--combine", is_flag=True, help="Combine all changes into a single commit")
+@click.option("-d", "--debug", is_flag=True, help="Enable debug logging")
+def main(yes: bool, combine: bool, debug: bool) -> None:
+    """Create structured git commits with AI-generated messages."""
+    loom = CommitLoom()
+    loom.run(auto_commit=yes, combine_commits=combine, debug=debug)
+
 
 if __name__ == "__main__":
     main()
diff --git a/commitloom/cli/console.py b/commitloom/cli/console.py
@@ -1,9 +1,11 @@
 """Console output formatting and user interaction."""
 
 
+import logging
 from unittest.mock import MagicMock
 
 from rich.console import Console
+from rich.logging import RichHandler
 from rich.panel import Panel
 from rich.progress import (
     BarColumn,
@@ -27,6 +29,57 @@
 from ..services.ai_service import TokenUsage
 
 console = Console()
+logger = logging.getLogger("commitloom")
+
+
+def setup_logging(debug: bool = False):
+    """Configure logging with optional debug mode."""
+    level = logging.DEBUG if debug else logging.INFO
+
+    # Configure rich handler
+    rich_handler = RichHandler(rich_tracebacks=True, markup=True, show_time=debug, show_path=debug)
+    rich_handler.setLevel(level)
+
+    # Configure logger
+    logger.setLevel(level)
+    logger.addHandler(rich_handler)
+
+    if debug:
+        logger.debug("Debug mode enabled")
+
+
+def print_debug(message: str, exc_info: bool = False) -> None:
+    """Print debug message if debug mode is enabled.
+
+    Args:
+        message: The message to print
+        exc_info: Whether to include exception info in the log
+    """
+    logger.debug(f"🔍 {message}", exc_info=exc_info)
+
+
+def print_info(message: str) -> None:
+    """Print info message."""
+    logger.info(f"ℹ️ {message}")
+    console.print(f"\n[bold blue]ℹ️ {message}[/bold blue]")
+
+
+def print_warning(message: str) -> None:
+    """Print warning message."""
+    logger.warning(f"⚠️ {message}")
+    console.print(f"\n[bold yellow]⚠️ {message}[/bold yellow]")
+
+
+def print_error(message: str) -> None:
+    """Print error message."""
+    logger.error(f"❌ {message}")
+    console.print(f"\n[bold red]❌ {message}[/bold red]")
+
+
+def print_success(message: str) -> None:
+    """Print success message."""
+    logger.info(f"✅ {message}")
+    console.print(f"\n[bold green]✅ {message}[/bold green]")
 
 
 def create_progress() -> Progress:
@@ -42,9 +95,7 @@ def create_progress() -> Progress:
 
 def print_changed_files(files: list[GitFile]) -> None:
     """Print list of changed files."""
-    console.print(
-        "\n[bold blue]📜 Changes detected in the following files:[/bold blue]"
-    )
+    console.print("\n[bold blue]📜 Changes detected in the following files:[/bold blue]")
     for file in files:
         console.print(f"  - [cyan]{file.path}[/cyan]")
 
@@ -66,7 +117,7 @@ def print_warnings(warnings: list[AnalyzerWarning] | CommitAnalysis) -> None:
         icon = "🔴" if warning.level == WarningLevel.HIGH else "🟡"
         console.print(f"{icon} {warning.message}")
 
-    if 'analysis' in locals():
+    if "analysis" in locals():
         console.print("\n[cyan]📊 Commit Statistics:[/cyan]")
         console.print(f"  • Estimated tokens: {analysis.estimated_tokens:,}")
         console.print(f"  • Estimated cost: €{analysis.estimated_cost:.4f}")
@@ -75,9 +126,7 @@ def print_warnings(warnings: list[AnalyzerWarning] | CommitAnalysis) -> None:
 
 def print_batch_start(batch_num: int, total_batches: int, files: list[GitFile]) -> None:
     """Print information about starting a new batch."""
-    console.print(
-        f"\n[bold blue]📦 Processing Batch {batch_num}/{total_batches}[/bold blue]"
-    )
+    console.print(f"\n[bold blue]📦 Processing Batch {batch_num}/{total_batches}[/bold blue]")
     console.print("[cyan]Files in this batch:[/cyan]")
     for file in files:
         console.print(f"  - [dim]{file.path}[/dim]")
@@ -147,32 +196,8 @@ def confirm_batch_continue() -> bool:
 
 def select_commit_strategy() -> str:
     """Ask user how they want to handle multiple commits."""
-    console.print(
-        "\n[bold blue]🤔 How would you like to handle the commits?[/bold blue]"
-    )
-    return Prompt.ask(
-        "Choose strategy", choices=["individual", "combined"], default="individual"
-    )
-
-
-def print_success(message: str) -> None:
-    """Print success message."""
-    console.print(f"\n[bold green]✅ {message}[/bold green]")
-
-
-def print_error(message: str) -> None:
-    """Print error message."""
-    console.print(f"\n[bold red]❌ {message}[/bold red]")
-
-
-def print_info(message: str) -> None:
-    """Print info message."""
-    console.print(f"\n[bold blue]ℹ️ {message}[/bold blue]")
-
-
-def print_warning(message: str) -> None:
-    """Print warning message."""
-    console.print(f"\n[bold yellow]⚠️ {message}[/bold yellow]")
+    console.print("\n[bold blue]🤔 How would you like to handle the commits?[/bold blue]")
+    return Prompt.ask("Choose strategy", choices=["individual", "combined"], default="individual")
 
 
 def print_analysis(analysis: CommitAnalysis | MagicMock, files: list[GitFile]) -> None:
diff --git a/commitloom/cli/main.py b/commitloom/cli/main.py
@@ -144,41 +144,91 @@ def _create_batches(self, changed_files: list[GitFile]) -> list[list[GitFile]]:
     def process_files_in_batches(
         self, changed_files: list[GitFile], auto_commit: bool = False
     ) -> list[dict]:
-        """Process files in batches if needed."""
+        """Process files in batches if needed.
+
+        This method implements a queue-based approach to process files in batches:
+        1. First unstages all files to start from a clean state (only if multiple batches)
+        2. Creates batches of files to process
+        3. For each batch:
+           - Stages only the files in the current batch
+           - Processes the batch
+           - If successful, keeps the commit and moves to next batch
+           - If failed, unstages and stops
+        """
+        console.print_debug("Starting batch processing")
+
+        # Create work queue
+        console.print_debug(f"Creating batches from {len(changed_files)} files")
         batches = self._create_batches(changed_files)
         if not batches:
+            console.print_debug("No valid files to process")
             return []
 
-        results = []
+        # Print batch processing plan
+        total_files = len(changed_files)
         total_batches = len(batches)
-
         console.print_info("\nProcessing files in batches...")
-        console.print_batch_summary(len(changed_files), total_batches)
+        console.print_batch_summary(total_files, total_batches)
 
-        try:
-            for i, batch in enumerate(batches, 1):
-                # Stage only the current batch files
+        # Start with a clean state only if we have multiple batches
+        if total_batches > 1:
+            console.print_debug("Multiple batches detected, resetting staged changes")
+            self.git.reset_staged_changes()
+        else:
+            console.print_debug("Single batch detected, proceeding without reset")
+
+        # Process each batch atomically
+        results = []
+        for batch_num, batch in enumerate(batches, 1):
+            try:
+                # 1. Stage current batch
                 batch_files = [f.path for f in batch]
+                console.print_debug(
+                    f"Staging files for batch {batch_num}: {', '.join(batch_files)}"
+                )
                 self.git.stage_files(batch_files)
-
-                # Process current batch
-                console.print_batch_start(i, total_batches, batch)
-                result = self._handle_batch(batch, i, total_batches, auto_commit, False)
-
+                console.print_batch_start(batch_num, total_batches, batch)
+
+                # 2. Process batch
+                console.print_debug(f"Processing batch {batch_num}/{total_batches}")
+                result = self._handle_batch(
+                    batch=batch,
+                    batch_num=batch_num,
+                    total_batches=total_batches,
+                    auto_commit=auto_commit,
+                    combine_commits=False,
+                )
+
+                # 3. Handle result
                 if result:
+                    # Batch processed successfully
+                    console.print_debug(f"Batch {batch_num} processed successfully")
                     results.append(result)
-                    # Only unstage if there are more batches to process
-                    if i < total_batches:
+                    # Clean staged files if more batches pending
+                    if batch_num < total_batches:
+                        console.print_debug("Cleaning staged files for next batch")
                         self.git.reset_staged_changes()
                 else:
+                    # Batch processing was cancelled or failed
+                    console.print_debug(f"Batch {batch_num} processing cancelled or failed")
                     # _handle_batch already called reset_staged_changes
                     break
 
-            return results
-        except GitError as e:
-            console.print_error(f"Error during batch processing: {str(e)}")
-            self.git.reset_staged_changes()
-            return []
+            except GitError as e:
+                console.print_error(f"Error processing batch {batch_num}: {str(e)}")
+                console.print_debug(f"Stack trace for batch {batch_num} error:", exc_info=True)
+                self.git.reset_staged_changes()
+                if not auto_commit and not console.confirm_action(
+                    "Continue with remaining batches?"
+                ):
+                    console.print_debug("User chose to stop batch processing after error")
+                    break
+                console.print_debug("Continuing with next batch after error")
+
+        console.print_debug(
+            f"Batch processing completed. Processed {len(results)}/{total_batches} batches"
+        )
+        return results
 
     def _create_combined_commit(self, batches: list[dict]) -> None:
         """Create a combined commit from all batches."""
@@ -214,18 +264,30 @@ def _create_combined_commit(self, batches: list[dict]) -> None:
         except GitError as e:
             console.print_error(f"Failed to create commit: {str(e)}")
 
-    def run(self, auto_commit: bool = False, combine_commits: bool = False) -> None:
-        """Run the main application logic."""
+    def run(
+        self, auto_commit: bool = False, combine_commits: bool = False, debug: bool = False
+    ) -> None:
+        """Run the commit creation process.
+
+        Args:
+            auto_commit: Whether to skip confirmation prompts
+            combine_commits: Whether to combine all changes into a single commit
+            debug: Whether to enable debug logging
+        """
         try:
-            console.print_info("Analyzing your changes...")
+            # Setup logging
+            console.setup_logging(debug)
+            console.print_debug("Starting CommitLoom")
 
             # Get and validate changed files
+            console.print_info("Analyzing your changes...")
             changed_files = self.git.get_changed_files()
             if not changed_files:
                 console.print_error("No changes detected in the staging area.")
                 return
 
             # Get diff and analyze complexity
+            console.print_debug("Getting diff and analyzing complexity")
             diff = self.git.get_diff(changed_files)
             analysis = self.analyzer.analyze_diff_complexity(diff, changed_files)
 
@@ -238,23 +300,17 @@ def run(self, auto_commit: bool = False, combine_commits: bool = False) -> None:
 
             # Process files in batches if needed
             if len(changed_files) > config.max_files_threshold:
-                # Save current state and unstage all files
-                self.git.stash_changes()
-                self.git.reset_staged_changes()
+                console.print_debug("Processing files in batches")
+                batches = self.process_files_in_batches(changed_files, auto_commit)
+                if not batches:
+                    return
 
-                try:
-                    # Process files in batches
-                    batches = self.process_files_in_batches(changed_files, auto_commit)
-                    if not batches:
-                        return
-
-                    if combine_commits:
-                        self._create_combined_commit(batches)
-                finally:
-                    # Restore any stashed changes
-                    self.git.pop_stashed_changes()
+                if combine_commits:
+                    console.print_debug("Combining commits")
+                    self._create_combined_commit(batches)
             else:
                 # Process as single commit
+                console.print_debug("Processing as single commit")
                 suggestion, usage = self.ai_service.generate_commit_message(diff, changed_files)
                 console.print_info("\nGenerated Commit Message:")
                 console.print_commit_message(suggestion.format_body())
@@ -268,11 +324,15 @@ def run(self, auto_commit: bool = False, combine_commits: bool = False) -> None:
 
         except GitError as e:
             console.print_error(f"An error occurred: {str(e)}")
+            if debug:
+                console.print_debug("Git error details:", exc_info=True)
         except KeyboardInterrupt:
             console.print_warning("\nOperation cancelled by user")
             self.git.reset_staged_changes()
         except Exception as e:
             console.print_error(f"An unexpected error occurred: {str(e)}")
+            if debug:
+                console.print_debug("Unexpected error details:", exc_info=True)
             self.git.reset_staged_changes()
             raise
 
diff --git a/poetry.lock b/poetry.lock
diff --git a/pyproject.toml b/pyproject.toml
@@ -38,6 +38,7 @@ python = "^3.11"
 python-dotenv = "^1.0.1"
 rich = "^13.9.4"
 requests = "^2.32.3"
+click = "^8.1.7"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^8.3.4"
