smart-commit-cli 0.1.0__py3-none-any.whl

smart_commit/__init__.py

@@ -0,0 +1,6 @@
+"""Smart Commit - AI-powered Git commit automation."""
+
+__version__ = "0.2.0"
+__author__ = "Smart Commit Contributors"
+__license__ = "MIT"
+

smart_commit/ai/__init__.py

@@ -0,0 +1,7 @@
+"""AI package."""
+
+from .client import LLMClient
+from .reviewer import ClusterReviewer
+
+__all__ = ["LLMClient", "ClusterReviewer"]
+

smart_commit/ai/client.py

@@ -0,0 +1,123 @@
+"""LLM client wrapper using LiteLLM."""
+
+from typing import List, Dict, Optional
+import json
+import time
+
+from ..config import Config
+from ..logger import get_logger
+from ..exceptions import LLMException, LLMTimeoutError, LLMRateLimitError
+from ..constants import MAX_LLM_RETRIES, LLM_TIMEOUT
+
+logger = get_logger("ai.client")
+
+
+class LLMClient:
+    """Wrapper around LiteLLM for multi-provider support."""
+
+    def __init__(self, config: Optional[Config] = None):
+        """Initialize LLM client.
+        
+        Args:
+            config: Configuration object.
+        """
+        self.config = config or Config.load()
+        self._init_client()
+
+    def _init_client(self):
+        """Initialize LiteLLM client."""
+        try:
+            import litellm
+            self.client = litellm
+            logger.info(f"LLM Client initialized: {self.config.provider}/{self.config.model}")
+        except ImportError:
+            logger.error("litellm not installed")
+            raise
+
+    def complete(self, prompt: str, max_retries: int = MAX_LLM_RETRIES) -> str:
+        """Make LLM completion request.
+        
+        Args:
+            prompt: Input prompt.
+            max_retries: Max retry attempts.
+        
+        Returns:
+            LLM response.
+        
+        Raises:
+            LLMException: If request fails.
+        """
+        for attempt in range(max_retries):
+            try:
+                response = self.client.completion(
+                    model=self._get_model_name(),
+                    messages=[{"role": "user", "content": prompt}],
+                    api_key=self.config.api_key,
+                    temperature=0.3,
+                    max_tokens=1000,
+                    timeout=LLM_TIMEOUT,
+                )
+                
+                return response.choices[0].message.content
+                
+            except Exception as e:
+                error_str = str(e).lower()
+                
+                if "rate_limit" in error_str or "429" in error_str:
+                    if attempt < max_retries - 1:
+                        wait_time = 2 ** attempt
+                        logger.warning(f"Rate limited, waiting {wait_time}s...")
+                        time.sleep(wait_time)
+                        continue
+                    raise LLMRateLimitError(str(e))
+                
+                elif "timeout" in error_str:
+                    raise LLMTimeoutError(str(e))
+                
+                elif attempt == max_retries - 1:
+                    raise LLMException(str(e))
+                
+                else:
+                    logger.warning(f"LLM request failed (attempt {attempt + 1}): {e}")
+                    time.sleep(1)
+
+    def complete_json(self, prompt: str) -> Dict:
+        """Make LLM request expecting JSON response.
+        
+        Args:
+            prompt: Input prompt.
+        
+        Returns:
+            Parsed JSON response.
+        
+        Raises:
+            LLMException: If request fails or JSON parsing fails.
+        """
+        response = self.complete(prompt)
+        
+        try:
+            # Try to find JSON in response
+            import re
+            json_match = re.search(r'\{.*\}', response, re.DOTALL)
+            
+            if json_match:
+                json_str = json_match.group(0)
+                return json.loads(json_str)
+            else:
+                raise ValueError("No JSON found in response")
+                
+        except (json.JSONDecodeError, ValueError) as e:
+            logger.error(f"Failed to parse JSON response: {response}")
+            raise LLMException(f"Invalid JSON in LLM response: {e}")
+
+    def _get_model_name(self) -> str:
+        """Get full model name for LiteLLM.
+        
+        Returns:
+            Model name string.
+        """
+        if "/" in self.config.model:
+            return self.config.model
+        
+        return f"{self.config.provider}/{self.config.model}"
+

smart_commit/ai/reviewer.py

@@ -0,0 +1,91 @@
+"""LLM-based cluster review and refinement."""
+
+from typing import List, Optional
+import json
+
+from ..models import CommitCluster
+from ..logger import get_logger
+from .client import LLMClient
+
+logger = get_logger("ai.reviewer")
+
+
+class ClusterReviewer:
+    """Uses LLM to review and refine commit clusters."""
+
+    def __init__(self, llm_client: LLMClient):
+        """Initialize cluster reviewer.
+        
+        Args:
+            llm_client: LLMClient instance.
+        """
+        self.llm_client = llm_client
+
+    def review_cluster(self, cluster: CommitCluster) -> dict:
+        """Review a cluster and suggest improvements.
+        
+        Args:
+            cluster: CommitCluster to review.
+        
+        Returns:
+            Review result with suggestions.
+        """
+        if not cluster.summary:
+            return {"status": "skipped", "reason": "No summary"}
+        
+        file_list = "\n".join([f"  - {f.file_path}" for f in cluster.files[:5]])
+        if len(cluster.files) > 5:
+            file_list += f"\n  - ... and {len(cluster.files) - 5} more"
+        
+        prompt = f"""Review this commit group and decide if files belong together.
+
+Cluster Summary:
+{cluster.summary}
+
+Files ({len(cluster.files)} total):
+{file_list}
+
+Respond with JSON: {{"should_split": boolean, "confidence": 0.0-1.0, "reason": "..."}}
+Keep response concise."""
+        
+        try:
+            result = self.llm_client.complete_json(prompt)
+            
+            # Ensure required fields
+            return {
+                "should_split": result.get("should_split", False),
+                "confidence": float(result.get("confidence", 0.5)),
+                "reason": result.get("reason", "")
+            }
+            
+        except Exception as e:
+            logger.error(f"Cluster review failed: {e}")
+            return {"status": "error", "error": str(e)}
+
+    def should_merge_clusters(self, cluster1: CommitCluster, cluster2: CommitCluster) -> bool:
+        """Decide if two clusters should be merged.
+        
+        Args:
+            cluster1: First cluster.
+            cluster2: Second cluster.
+        
+        Returns:
+            True if clusters should be merged.
+        """
+        prompt = f"""Should these commits be merged into one?
+
+Commit 1: {cluster1.summary}
+Files: {len(cluster1.files)}
+
+Commit 2: {cluster2.summary}
+Files: {len(cluster2.files)}
+
+Respond with only 'yes' or 'no'."""
+        
+        try:
+            response = self.llm_client.complete(prompt).lower().strip()
+            return "yes" in response
+        except Exception as e:
+            logger.error(f"Merge decision failed: {e}")
+            return False
+

smart_commit/ai.py

@@ -0,0 +1,136 @@
+"""AI pipeline for cluster refinement and analysis."""
+
+from typing import List, Optional
+from .models import CommitCluster, CommitType
+from .config import Config
+
+
+class AIAnalyzer:
+    """Uses LLM to review and refine commit clusters."""
+
+    def __init__(self, config: Optional[Config] = None):
+        """Initialize AI analyzer.
+        
+        Args:
+            config: Configuration object. If None, loads from environment.
+        """
+        self.config = config or Config.load()
+        self._init_llm()
+
+    def _init_llm(self):
+        """Initialize LLM client."""
+        try:
+            import litellm
+            self.llm = litellm
+        except ImportError:
+            raise ImportError("litellm not installed. Install with: pip install litellm")
+
+    def review_cluster(self, cluster: CommitCluster) -> dict:
+        """Use LLM to review and improve a cluster.
+        
+        Args:
+            cluster: CommitCluster to review.
+        
+        Returns:
+            Review result with suggestions.
+        """
+        if not cluster.summary:
+            return {"status": "skipped", "reason": "No summary"}
+        
+        prompt = f"""
+You are an expert software engineer reviewing a commit group.
+
+Cluster Summary:
+{cluster.summary}
+
+Files in cluster: {len(cluster.files)}
+- {', '.join(f.file_path for f in cluster.files[:3])}
+
+Assess if these files logically belong together. Should they be split into separate commits?
+Respond with JSON: {{"should_split": boolean, "reason": "...", "suggestions": ["..."]}}
+"""
+        
+        try:
+            response = self.llm.completion(
+                model=f"{self.config.provider}/{self.config.model}" if "/" not in self.config.model else self.config.model,
+                messages=[{"role": "user", "content": prompt}],
+                api_key=self.config.api_key,
+                temperature=0.3,
+                max_tokens=200
+            )
+            
+            # Parse response
+            import json
+            content = response.choices[0].message.content
+            
+            try:
+                result = json.loads(content)
+                return result
+            except json.JSONDecodeError:
+                return {"status": "error", "raw_response": content}
+                
+        except Exception as e:
+            return {"status": "error", "error": str(e)}
+
+    def should_merge_clusters(self, cluster1: CommitCluster, cluster2: CommitCluster) -> bool:
+        """Use LLM to decide if two clusters should be merged.
+        
+        Args:
+            cluster1: First cluster.
+            cluster2: Second cluster.
+        
+        Returns:
+            True if clusters should be merged.
+        """
+        prompt = f"""
+Should these two commit groups be merged into one?
+
+Group 1: {cluster1.summary}
+Group 2: {cluster2.summary}
+
+Respond with just 'yes' or 'no'.
+"""
+        
+        try:
+            response = self.llm.completion(
+                model=f"{self.config.provider}/{self.config.model}" if "/" not in self.config.model else self.config.model,
+                messages=[{"role": "user", "content": prompt}],
+                api_key=self.config.api_key,
+                temperature=0.3,
+                max_tokens=10
+            )
+            
+            answer = response.choices[0].message.content.lower().strip()
+            return "yes" in answer
+            
+        except Exception:
+            return False
+
+    def suggest_commit_type(self, cluster: CommitCluster) -> Optional[CommitType]:
+        """Suggest a Conventional Commit type for a cluster.
+        
+        Args:
+            cluster: CommitCluster to analyze.
+        
+        Returns:
+            Suggested CommitType.
+        """
+        if not cluster.summary:
+            return CommitType.CHORE
+        
+        summary_lower = cluster.summary.lower()
+        
+        # Simple heuristics (can be improved with LLM)
+        if any(x in summary_lower for x in ['fix', 'bug', 'issue']):
+            return CommitType.FIX
+        elif any(x in summary_lower for x in ['feat', 'feature', 'add', 'implement']):
+            return CommitType.FEAT
+        elif any(x in summary_lower for x in ['refactor', 'clean', 'improve']):
+            return CommitType.REFACTOR
+        elif any(x in summary_lower for x in ['test', 'spec']):
+            return CommitType.TEST
+        elif any(x in summary_lower for x in ['doc', 'readme', 'comment']):
+            return CommitType.DOCS
+        
+        return CommitType.CHORE
+

smart_commit/analysis/__init__.py

@@ -0,0 +1,7 @@
+"""Analysis package."""
+
+from .diff_parser import DiffParser
+from .summarizer import Summarizer
+
+__all__ = ["DiffParser", "Summarizer"]
+

smart_commit/analysis/ast_parser.py

@@ -0,0 +1,173 @@
+"""Abstract Syntax Tree parsing for better code understanding."""
+
+from typing import List, Optional
+from ..logger import get_logger
+
+logger = get_logger("analysis.ast_parser")
+
+
+class ASTParser:
+    """Parse AST for language-specific symbol extraction."""
+
+    def __init__(self, language: str):
+        """Initialize AST parser.
+        
+        Args:
+            language: Programming language (python, javascript, typescript, etc.)
+        """
+        self.language = language.lower()
+        self._init_parser()
+
+    def _init_parser(self):
+        """Initialize language-specific parser."""
+        # Note: Full AST parsing requires tree-sitter or language-specific libraries
+        # This is a foundation for future expansion
+        
+        if self.language in ["python"]:
+            self._try_import_python_parser()
+        elif self.language in ["javascript", "typescript", "jsx", "tsx"]:
+            self._try_import_js_parser()
+        else:
+            logger.debug(f"No AST parser available for {self.language}")
+
+    def _try_import_python_parser(self):
+        """Try to import Python AST parser."""
+        try:
+            import ast
+            self.parser = ast
+            logger.debug("Python AST parser initialized")
+        except ImportError:
+            logger.debug("ast module not available")
+
+    def _try_import_js_parser(self):
+        """Try to import JavaScript/TypeScript parser."""
+        try:
+            import tree_sitter
+            try:
+                # new tree_sitter api in 0.22+
+                import tree_sitter_javascript as ts_js
+                JS_LANGUAGE = tree_sitter.Language(ts_js.language())
+                self.js_parser = tree_sitter.Parser(JS_LANGUAGE)
+                logger.debug("tree-sitter javascript initialized")
+            except Exception as e:
+                logger.debug(f"Failed to load tree_sitter_javascript: {e}")
+                self.js_parser = None
+        except ImportError:
+            logger.debug("tree-sitter not installed")
+            self.js_parser = None
+
+    def extract_functions(self, source_code: str) -> List[str]:
+        """Extract function names from source code.
+        
+        Args:
+            source_code: Source code string.
+        
+        Returns:
+            List of function names.
+        """
+        if self.language == "python":
+            return self._extract_python_functions(source_code)
+        elif self.language in ["javascript", "typescript", "jsx", "tsx"]:
+            return self._extract_js_functions(source_code)
+        
+        return []
+
+    def extract_classes(self, source_code: str) -> List[str]:
+        """Extract class names from source code.
+        
+        Args:
+            source_code: Source code string.
+        
+        Returns:
+            List of class names.
+        """
+        if self.language == "python":
+            return self._extract_python_classes(source_code)
+        
+        return []
+
+    def extract_imports(self, source_code: str) -> List[str]:
+        """Extract imported modules.
+        
+        Args:
+            source_code: Source code string.
+        
+        Returns:
+            List of imported modules.
+        """
+        if self.language == "python":
+            return self._extract_python_imports(source_code)
+        
+        return []
+
+    def _extract_python_functions(self, source_code: str) -> List[str]:
+        """Extract Python function names."""
+        try:
+            import ast
+            tree = ast.parse(source_code)
+            
+            functions = []
+            for node in ast.walk(tree):
+                if isinstance(node, ast.FunctionDef):
+                    functions.append(node.name)
+            
+            return functions
+        except Exception as e:
+            logger.debug(f"Failed to extract Python functions: {e}")
+            return []
+
+    def _extract_python_classes(self, source_code: str) -> List[str]:
+        """Extract Python class names."""
+        try:
+            import ast
+            tree = ast.parse(source_code)
+            
+            classes = []
+            for node in ast.walk(tree):
+                if isinstance(node, ast.ClassDef):
+                    classes.append(node.name)
+            
+            return classes
+        except Exception as e:
+            logger.debug(f"Failed to extract Python classes: {e}")
+            return []
+
+    def _extract_python_imports(self, source_code: str) -> List[str]:
+        """Extract Python import statements."""
+        try:
+            import ast
+            tree = ast.parse(source_code)
+            
+            imports = []
+            for node in ast.walk(tree):
+                if isinstance(node, ast.Import):
+                    for alias in node.names:
+                        imports.append(alias.name)
+                elif isinstance(node, ast.ImportFrom):
+                    if node.module:
+                        imports.append(node.module)
+            
+            return list(set(imports))  # Deduplicate
+        except Exception as e:
+            logger.debug(f"Failed to extract Python imports: {e}")
+            return []
+
+    def _extract_js_functions(self, source_code: str) -> List[str]:
+        if not getattr(self, "js_parser", None):
+            return []
+        try:
+            tree = self.js_parser.parse(bytes(source_code, "utf8"))
+            query = self.js_parser.language.query("""
+                (function_declaration name: (identifier) @name)
+                (method_definition name: (property_identifier) @name)
+                (arrow_function) @name
+            """)
+            captures = query.captures(tree.root_node)
+            functions = []
+            for node, _ in captures.get("name", []):
+                functions.append(node.text.decode("utf8"))
+            return functions
+        except Exception as e:
+            logger.debug(f"Failed to extract JS functions: {e}")
+            return []
+

smart_commit/analysis/dependency_graph.py

@@ -0,0 +1,114 @@
+"""Dependency graph for repository topology."""
+
+import os
+import networkx as nx
+from pathlib import Path
+from typing import Dict, List, Set, Optional
+
+from ..logger import get_logger
+from ..cache import cache_manager
+from .ast_parser import ASTParser
+
+logger = get_logger("analysis.dependency_graph")
+
+
+class DependencyGraph:
+    """Builds and queries a module dependency graph."""
+
+    def __init__(self, repo_path: Path):
+        self.repo_path = repo_path
+        self.graph = nx.DiGraph()
+        self._build_graph()
+
+    def _build_graph(self):
+        """Build the dependency graph for the repository."""
+        # Try to load from cache
+        cached_edges = cache_manager.get("dependency_graph", str(self.repo_path))
+        
+        if cached_edges is not None:
+            self.graph.add_edges_from(cached_edges)
+            return
+
+        # If not cached, we build a partial graph of known imports.
+        # To make it fast, we will only build it based on cached file contents
+        # or we scan the repo. Since full scan is heavy, we'll do a simple heuristic
+        # scan of Python and JS/TS files.
+        edges = set()
+        
+        # We will do a fast walk for .py, .js, .ts files
+        for root, dirs, files in os.walk(self.repo_path):
+            # Skip hidden dirs and node_modules
+            dirs[:] = [d for d in dirs if not d.startswith('.') and d not in ('node_modules', 'venv', 'env', '__pycache__')]
+            
+            for file in files:
+                ext = file.split('.')[-1].lower() if '.' in file else ''
+                if ext in ['py', 'js', 'ts', 'jsx', 'tsx']:
+                    file_path = Path(root) / file
+                    rel_path = file_path.relative_to(self.repo_path).as_posix()
+                    
+                    try:
+                        content = file_path.read_text(encoding="utf-8", errors="ignore")
+                        lang = "python" if ext == "py" else "javascript"
+                        parser = ASTParser(lang)
+                        imports = parser.extract_imports(content)
+                        
+                        # Add edges (module -> dependency)
+                        # We don't resolve full absolute paths perfectly, but strings match
+                        for imp in imports:
+                            edges.add((rel_path, imp))
+                    except Exception as e:
+                        logger.debug(f"Failed to parse {rel_path} for dependencies: {e}")
+
+        self.graph.add_edges_from(edges)
+        cache_manager.set("dependency_graph", str(self.repo_path), list(edges))
+
+    def get_neighbors(self, file_path: str) -> List[str]:
+        """Get list of connected files (imports or imported by)."""
+        if not self.graph.has_node(file_path):
+            # Try to match without extension
+            base = file_path.rsplit('.', 1)[0]
+            matches = [n for n in self.graph.nodes if n.startswith(base) or (isinstance(n, str) and base in n)]
+            if not matches:
+                return []
+            file_path = matches[0]
+
+        try:
+            predecessors = list(self.graph.predecessors(file_path))
+            successors = list(self.graph.successors(file_path))
+            return list(set(predecessors + successors))
+        except nx.NetworkXError:
+            return []
+
+    def get_distance(self, file1: str, file2: str) -> float:
+        """Get shortest path distance between two files in the graph.
+        
+        Returns:
+            Distance (1.0 for adjacent, 2.0 for 2 hops, etc.), or infinity if disconnected.
+        """
+        # Node matching heuristics
+        n1, n2 = file1, file2
+        if not self.graph.has_node(n1):
+            n1 = self._find_best_node(file1)
+        if not self.graph.has_node(n2):
+            n2 = self._find_best_node(file2)
+            
+        if not n1 or not n2:
+            return float('inf')
+            
+        try:
+            # Undirected shortest path for topological distance
+            undirected = self.graph.to_undirected()
+            return float(nx.shortest_path_length(undirected, n1, n2))
+        except (nx.NetworkXNoPath, nx.NodeNotFound):
+            return float('inf')
+            
+    def _find_best_node(self, file_path: str) -> Optional[str]:
+        """Heuristically find a node matching the file path."""
+        base = file_path.rsplit('.', 1)[0]
+        # Match exact suffix (e.g. from.module import X -> X might be a node)
+        for n in self.graph.nodes:
+            if not isinstance(n, str):
+                continue
+            if n == file_path or n == base or n.endswith('.' + base) or n.endswith('/' + base):
+                return n
+        return None