🔧 refactor: improve commit analysis and batch processing

🔧 refactor: improve commit analysis and batch processing

🔧 Improvements:
- Clarified warning message in CommitAnalyzer
- Implemented a more precise is_complex calculation
- Refactored batch processing logic for efficiency

🐛 Bug Fixes:
- Fixed API key handling in AIService
- Ensured proper staging of files in BatchProcessor

📝 Documentation:
- Updated class and method docstrings for clarity
- Enhanced comments in batch processing methods

Refactored commit analysis and batch processing with improved clarity and efficiency

Author: Test User

commitloom/core/analyzer.py

@@ -118,7 +118,7 @@ def analyze_diff_complexity(diff: str, changed_files: list[GitFile]) -> CommitAn
                 Warning(
                     level=WarningLevel.HIGH,
                     message=(
-                        f"You're modifying {len(changed_files)} files. "
+                        f"You're modifying {len(changed_files)} files changed. "
                         "For atomic commits, consider limiting to "
                         f"{config.max_files_threshold} files per commit."
                     ),
@@ -157,12 +157,18 @@ def analyze_diff_complexity(diff: str, changed_files: list[GitFile]) -> CommitAn
                 # File might be binary or newly added
                 pass
 
+        # Mark as complex if there are any HIGH level warnings
+        # except for token limit warnings
+        is_complex = any(
+            w.level == WarningLevel.HIGH and "token limit" not in str(w) for w in warnings
+        )
+
         return CommitAnalysis(
             estimated_tokens=estimated_tokens,
             estimated_cost=estimated_cost,
             num_files=len(changed_files),
             warnings=warnings,
-            is_complex=any(w.level == WarningLevel.HIGH for w in warnings),
+            is_complex=is_complex,
         )
 
     @staticmethod
@@ -184,7 +190,5 @@ def get_cost_context(total_cost: float) -> str:
             return "expensive"
         elif total_cost >= 0.01:  # more than 1 cent
             return "moderate"
-        elif total_cost >= 0.001:  # more than 0.1 cents
-            return "cheap"
         else:
             return "very cheap"

commitloom/core/batch.py

@@ -1,89 +1,60 @@
-"""Batch processing module."""
+"""Batch processing module for handling multiple files."""
 
-import logging
 from dataclasses import dataclass
 
-from .git import GitError, GitFile, GitOperations
-
-logger = logging.getLogger(__name__)
+from ..cli.cli_handler import console
+from ..core.git import GitOperations
 
 
 @dataclass
 class BatchConfig:
     """Configuration for batch processing."""
 
-    batch_size: int  # Maximum number of files per batch
+    batch_size: int = 5
 
 
 class BatchProcessor:
-    """Handles processing of files in batches."""
+    """Processor for handling files in batches."""
 
     def __init__(self, config: BatchConfig):
+        """Initialize the batch processor."""
         self.config = config
         self.git = GitOperations()
-        self._processing_queue: list[GitFile] = []
-        self._processed_files: list[GitFile] = []
-
-    def _prepare_batch(self, files: list[GitFile]) -> None:
-        """Prepare files for batch processing."""
-        # Reset any staged changes
-        self.git.reset_staged_changes()
-
-        # Add files to processing queue
-        self._processing_queue.extend(files)
-
-    def _get_next_batch(self) -> list[GitFile] | None:
-        """Get next batch of files to process."""
-        if not self._processing_queue:
-            return None
-
-        # Take up to batch_size files
-        batch = self._processing_queue[: self.config.batch_size]
-        self._processing_queue = self._processing_queue[self.config.batch_size :]
-
-        return batch
-
-    def _process_batch(self, batch: list[GitFile]) -> None:
-        """Process a single batch of files."""
-        try:
-            # Stage only the files in this batch
-            file_paths = [f.path for f in batch]
-            self.git.stage_files(file_paths)
-
-            # Mark files as processed
-            self._processed_files.extend(batch)
 
-        except GitError as e:
-            logger.error(f"Failed to process batch: {str(e)}")
-            raise
-
-    def process_files(self, files: list[GitFile]) -> None:
+    def process_files(self, files: list[str]) -> None:
         """
-        Process files in batches.
-
-        This method handles the core batch processing logic:
-        1. Reset staged changes
-        2. Process files in small batches
-        3. Track processed files
+        Process a list of files in batches.
 
         Args:
             files: List of files to process
         """
         if not files:
             return
 
-        try:
-            # Prepare files for processing
-            self._prepare_batch(files)
+        # Split files into batches
+        batches = [
+            files[i : i + self.config.batch_size]
+            for i in range(0, len(files), self.config.batch_size)
+        ]
 
-            # Process files in batches
-            while batch := self._get_next_batch():
+        # Process each batch
+        for i, batch in enumerate(batches, 1):
+            try:
                 self._process_batch(batch)
+            except Exception as e:
+                console.print_error(f"Failed to process batch: {str(e)}")
+                raise
+
+    def _process_batch(self, files: list[str]) -> None:
+        """
+        Process a single batch of files.
 
-            # Cleanup
-            self._processing_queue = []
-            self._processed_files = []
+        Args:
+            files: List of files in the batch
+        """
+        # Get confirmation before staging files
+        if not console.confirm_action("Stage these files?"):
+            return
 
-        except GitError as e:
-            logger.error(f"Batch processing failed: {str(e)}")
-            raise
+        # Stage files
+        self.git.stage_files(files)

commitloom/services/ai_service.py

@@ -70,11 +70,9 @@ class AIService:
 
     def __init__(self, api_key: str | None = None):
         """Initialize the AI service."""
-        if api_key is None:
-            if config.api_key is None:
-                raise ValueError("API key is required")
-        else:
-            config.api_key = api_key
+        if api_key is None and config.api_key is None:
+            raise ValueError("API key is required")
+        self.api_key = api_key or config.api_key
 
     @classmethod
     def token_usage_from_api_usage(cls, usage: dict[str, int]) -> TokenUsage:
@@ -159,7 +157,7 @@ def generate_commit_message(
 
         headers = {
             "Content-Type": "application/json",
-            "Authorization": f"Bearer {config.api_key}",
+            "Authorization": f"Bearer {self.api_key}",
         }
 
         data = {