feat(core): Add timeout to OllamaClient

Adds a timeout to the `OllamaClient` to prevent indefinite waits during API calls. This improves the robustness of the application by ensuring operations complete within a reasonable timeframe. The timeout value is configurable and helps avoid blocking the main thread. This change enhances the overall reliability of interacting with the Ollama API.
Affected files:
- M setup.py
- M smart_git_commit.py
- M tests/test_smart_git_commit.py
- + run_tests.py

Author: CripterHack

run_tests.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""
+Helper script to run tests with coverage reporting for the Smart Git Commit tool.
+"""
+
+import os
+import sys
+import subprocess
+import argparse
+
+
+def run_tests(verbose=False, coverage=False):
+    """Run the test suite with optional coverage reporting."""
+    print("Running Smart Git Commit tests...")
+    
+    cmd = ["python", "-m", "unittest", "discover", "-s", "tests"]
+    
+    if verbose:
+        cmd.append("-v")
+    
+    if coverage:
+        try:
+            # Check if coverage is installed
+            import coverage
+            print("Running tests with coverage reporting...")
+            
+            # Create a coverage object
+            cov = coverage.Coverage()
+            cov.start()
+            
+            # Run the tests
+            subprocess.run(cmd, check=True)
+            
+            # Stop coverage and generate report
+            cov.stop()
+            cov.save()
+            
+            print("\nCoverage report:")
+            cov.report()
+            
+            # Generate HTML report
+            report_dir = os.path.join(os.path.dirname(__file__), "coverage_html")
+            cov.html_report(directory=report_dir)
+            print(f"\nDetailed HTML coverage report generated in: {report_dir}")
+            
+            return True
+        
+        except ImportError:
+            print("Warning: coverage package not installed. Running tests without coverage.")
+            coverage = False
+    
+    if not coverage:
+        # Run tests without coverage
+        result = subprocess.run(cmd)
+        return result.returncode == 0
+
+
+def parse_args():
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(description="Run tests for Smart Git Commit")
+    parser.add_argument("-v", "--verbose", action="store_true", help="Run tests in verbose mode")
+    parser.add_argument("-c", "--coverage", action="store_true", help="Generate coverage report")
+    
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    success = run_tests(verbose=args.verbose, coverage=args.coverage)
+    sys.exit(0 if success else 1) 

setup.py

@@ -13,7 +13,7 @@
 
 setup(
     name="smart-git-commit",
-    version="0.1.4",
+    version="0.1.5",
     description="AI-powered Git commit workflow tool",
     long_description=long_description,
     long_description_content_type="text/markdown",

smart_git_commit.py

@@ -197,32 +197,39 @@ def generate_commit_message(self) -> str:
 class OllamaClient:
     """Client for interacting with Ollama API with GPU acceleration."""
 
-    def __init__(self, host: str = "http://localhost:11434", model: Optional[str] = None):
+    def __init__(self, host: str = "http://localhost:11434", model: Optional[str] = None, timeout: int = 10):
         """
         Initialize the Ollama client.
         
         Args:
             host: Host for Ollama API
             model: Model to use for Ollama, if None will prompt user to select one
+            timeout: Timeout in seconds for HTTP requests
         """
         self.host = host
         self.headers = {"Content-Type": "application/json"}
-        self.available_models = self._get_available_models()
+        self.timeout = timeout
 
-        if not self.available_models:
-            logger.warning("No models found in Ollama. Make sure Ollama is running.")
-            raise RuntimeError("No Ollama models available")
+        try:
+            self.available_models = self._get_available_models()
 
-        if model is None:
-            self.model = self._select_model()
-        else:
-            if model not in self.available_models:
-                logger.warning(f"Model {model} not found. Available models: {', '.join(self.available_models)}")
+            if not self.available_models:
+                logger.warning("No models found in Ollama. Make sure Ollama is running.")
+                raise RuntimeError("No Ollama models available")
+                
+            if model is None:
                 self.model = self._select_model()
             else:
-                self.model = model
-                
-        logger.info(f"Using Ollama model: {self.model}")
+                if model not in self.available_models:
+                    logger.warning(f"Model {model} not found. Available models: {', '.join(self.available_models)}")
+                    self.model = self._select_model()
+                else:
+                    self.model = model
+                    
+            logger.info(f"Using Ollama model: {self.model}")
+        except Exception as e:
+            logger.error(f"Error initializing Ollama client: {str(e)}")
+            raise
 
     def _get_host_connection(self) -> Tuple[str, int]:
         """Parse host string and return connection parameters."""
@@ -239,9 +246,25 @@ def _get_host_connection(self) -> Tuple[str, int]:
                 host = self.host.split(':')[0]  # Handle case if port is included
                 port = 11434
 
-            # Test connection before returning
+            # Test connection before returning with a short timeout
+            socket.setdefaulttimeout(self.timeout)
             socket.getaddrinfo(host, port)
             return host, port
+        except socket.gaierror as e:
+            logger.warning(f"DNS resolution error for {self.host}: {str(e)}")
+            # Fall back to localhost if specified host fails
+            if self.host != "localhost" and self.host != "http://localhost:11434":
+                logger.info("Trying localhost as fallback")
+                self.host = "http://localhost:11434"
+                return "localhost", 11434
+            raise
+        except socket.timeout:
+            logger.warning(f"Connection timeout to {self.host}")
+            if self.host != "localhost" and self.host != "http://localhost:11434":
+                logger.info("Trying localhost as fallback")
+                self.host = "http://localhost:11434"
+                return "localhost", 11434
+            raise RuntimeError(f"Connection timeout to {self.host}")
         except Exception as e:
             logger.warning(f"Connection error to {self.host}: {str(e)}")
             # Fall back to localhost if specified host fails
@@ -255,9 +278,14 @@ def _get_available_models(self) -> List[str]:
         """Get a list of available models from Ollama."""
         try:
             host, port = self._get_host_connection()
-            conn = http.client.HTTPConnection(host, port)
+            conn = http.client.HTTPConnection(host, port, timeout=self.timeout)
             conn.request("GET", "/api/tags")
             response = conn.getresponse()
+            
+            if response.status != 200:
+                logger.warning(f"Failed to get models: HTTP {response.status} {response.reason}")
+                return self._get_models_from_cli()
+                
             data = json.loads(response.read().decode())
 
             # Different Ollama API versions might return models differently
@@ -271,6 +299,15 @@ def _get_available_models(self) -> List[str]:
                 # Try to run ollama list directly if API doesn't work
                 return self._get_models_from_cli()
 
+        except json.JSONDecodeError:
+            logger.warning("Invalid JSON response from Ollama API")
+            return self._get_models_from_cli()
+        except http.client.HTTPException as e:
+            logger.warning(f"HTTP error when connecting to Ollama: {str(e)}")
+            return self._get_models_from_cli()
+        except socket.timeout:
+            logger.warning("Connection timeout when retrieving models from Ollama API")
+            return self._get_models_from_cli()
         except Exception as e:
             logger.warning(f"Failed to get models from Ollama API: {str(e)}")
             # Try command-line fallback
@@ -285,8 +322,9 @@ def _get_models_from_cli(self) -> List[str]:
                 stderr=subprocess.PIPE,
                 text=True
             )
-            stdout, stderr = process.communicate()
+            stdout, stderr = process.communicate(timeout=self.timeout)
             if process.returncode != 0:
+                logger.warning(f"Ollama CLI failed with error: {stderr}")
                 return []
 
             models = []
@@ -297,7 +335,14 @@ def _get_models_from_cli(self) -> List[str]:
                     if parts:
                         models.append(parts[0])
             return models
-        except Exception:
+        except subprocess.TimeoutExpired:
+            logger.warning("Timeout running 'ollama list' command")
+            return []
+        except FileNotFoundError:
+            logger.warning("Ollama command not found in PATH")
+            return []
+        except Exception as e:
+            logger.warning(f"Error getting models from CLI: {str(e)}")
             return []
 
     def _select_model(self) -> str:
@@ -321,12 +366,16 @@ def _select_model(self) -> str:
                 if selection in self.available_models:
                     return selection
                 print("Please enter a valid model number or name")
+            except KeyboardInterrupt:
+                # If user interrupts, use first model as default
+                print("\nInterrupted, using first available model")
+                return self.available_models[0]
 
     def generate(self, prompt: str, system_prompt: str = "", max_tokens: int = 2000) -> str:
         """Generate text using Ollama."""
         try:
             host, port = self._get_host_connection()
-            conn = http.client.HTTPConnection(host, port)
+            conn = http.client.HTTPConnection(host, port, timeout=self.timeout)
 
             data = {
                 "model": self.model,
@@ -338,9 +387,23 @@ def generate(self, prompt: str, system_prompt: str = "", max_tokens: int = 2000)
 
             conn.request("POST", "/api/generate", json.dumps(data), self.headers)
             response = conn.getresponse()
+            
+            if response.status != 200:
+                logger.warning(f"Failed to generate text: HTTP {response.status} {response.reason}")
+                return ""
+                
             result = json.loads(response.read().decode())
 
             return result.get("response", "")
+        except json.JSONDecodeError:
+            logger.warning("Invalid JSON response from Ollama API during generation")
+            return ""
+        except http.client.HTTPException as e:
+            logger.warning(f"HTTP error when generating text: {str(e)}")
+            return ""
+        except socket.timeout:
+            logger.warning("Timeout when generating text with Ollama")
+            return ""
         except Exception as e:
             logger.warning(f"Failed to generate text with Ollama: {str(e)}")
             return ""
@@ -350,7 +413,7 @@ class SmartGitCommitWorkflow:
     """Manages the workflow for analyzing, grouping, and committing changes with AI assistance."""
 
     def __init__(self, repo_path: str = ".", ollama_host: str = "http://localhost:11434", 
-                 ollama_model: Optional[str] = None, use_ai: bool = True):
+                 ollama_model: Optional[str] = None, use_ai: bool = True, timeout: int = 10):
         """
         Initialize the workflow.
         
@@ -359,16 +422,18 @@ def __init__(self, repo_path: str = ".", ollama_host: str = "http://localhost:11
             ollama_host: Host for Ollama API
             ollama_model: Model to use for Ollama, if None will prompt user to select
             use_ai: Whether to use AI-powered analysis
+            timeout: Timeout in seconds for HTTP requests to Ollama
         """
         self.repo_path = repo_path
         self.changes: List[GitChange] = []
         self.commit_groups: List[CommitGroup] = []
         self.use_ai = use_ai
         self.ollama = None
+        self.timeout = timeout
 
         if use_ai:
             try:
-                self.ollama = OllamaClient(host=ollama_host, model=ollama_model)
+                self.ollama = OllamaClient(host=ollama_host, model=ollama_model, timeout=timeout)
             except Exception as e:
                 logger.warning(f"Failed to initialize Ollama client: {str(e)}")
                 logger.info("Falling back to rule-based analysis")
@@ -448,6 +513,10 @@ def load_changes(self) -> None:
             status = line[:2].strip()
             filename = line[3:].strip()
 
+            # Remove any leading "backend/" or similar prefix that might come from running in a subdirectory
+            if " -> " in filename:  # Handle renamed files
+                old_path, filename = filename.split(" -> ")
+            
             # Get diff content for modified files
             content_diff = None
             if status != "??":  # Not for untracked files
@@ -884,15 +953,30 @@ def execute_commits(self, interactive: bool = True) -> None:
 
             # Execute the commit
             # Write commit message with UTF-8 encoding explicitly
-            commit_msg_path = os.path.join(self.repo_path, ".git", "COMMIT_EDITMSG")
             try:
+                # First make sure .git directory exists
+                git_dir = os.path.join(self.repo_path, ".git")
+                if not os.path.isdir(git_dir):
+                    # Try to find the git directory
+                    stdout, _ = self._run_git_command(["rev-parse", "--git-dir"])
+                    git_dir = stdout.strip()
+                    if not os.path.isdir(git_dir):
+                        git_dir = os.path.join(self.repo_path, git_dir)
+
+                # Now create the commit message file
+                commit_msg_path = os.path.join(git_dir, "COMMIT_EDITMSG")
+                
                 with open(commit_msg_path, "w", encoding='utf-8') as f:
                     f.write(commit_message)
 
-                stdout, code = self._run_git_command(["commit", "-F", os.path.join(".git", "COMMIT_EDITMSG")])
+                stdout, code = self._run_git_command(["commit", "-F", commit_msg_path])
+            except Exception as e:
+                logger.error(f"Failed to create or use commit message file: {str(e)}")
+                # Try direct commit as fallback
+                stdout, code = self._run_git_command(["commit", "-m", commit_message])
             finally:
                 # Clean up the temporary commit message file
-                if os.path.exists(commit_msg_path):
+                if 'commit_msg_path' in locals() and os.path.exists(commit_msg_path):
                     try:
                         os.remove(commit_msg_path)
                     except OSError as e:
@@ -962,14 +1046,16 @@ def main() -> int:
     parser.add_argument("--ollama-host", help="Host for Ollama API", default="http://localhost:11434")
     parser.add_argument("--ollama-model", help="Model to use for Ollama (will prompt if not specified)")
     parser.add_argument("--no-ai", action="store_true", help="Disable AI-powered analysis")
+    parser.add_argument("--timeout", type=int, help="Timeout in seconds for HTTP requests", default=10)
     args = parser.parse_args()
 
     try:
         workflow = SmartGitCommitWorkflow(
             repo_path=args.repo_path,
             ollama_host=args.ollama_host,
             ollama_model=args.ollama_model,
-            use_ai=not args.no_ai
+            use_ai=not args.no_ai,
+            timeout=args.timeout
         )
 
         workflow.load_changes()