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

smart_commit/committer.py

@@ -0,0 +1,91 @@
+"""Commit execution and session management."""
+
+from typing import List
+from pathlib import Path
+
+from .models import CommitCluster, SessionInfo, FileDiff
+from .git_service import GitService
+from .utils import generate_session_id, get_timestamp
+
+
+class Committer:
+    """Handles file staging, commit execution, and session management."""
+
+    def __init__(self, git_service: GitService):
+        """Initialize committer.
+        
+        Args:
+            git_service: GitService instance.
+        """
+        self.git_service = git_service
+        self.session = SessionInfo(
+            session_id=generate_session_id(),
+            timestamp=get_timestamp(),
+            branch=git_service.current_branch(),
+            repository_path=str(git_service.repo_path)
+        )
+
+    def commit_cluster(self, cluster: CommitCluster) -> str:
+        """Stage files and create a commit for a cluster.
+        
+        Args:
+            cluster: CommitCluster to commit.
+        
+        Returns:
+            Commit hash.
+        """
+        # Extract file paths
+        file_paths = [f.file_path for f in cluster.files]
+        
+        # Stage files
+        self.git_service.stage_files(file_paths)
+        
+        # Create commit
+        message = cluster.message or "Automatic commit"
+        commit_hash = self.git_service.commit(message)
+        
+        # Track in session
+        self.session.commit_hashes.append(commit_hash)
+        
+        return commit_hash
+
+    def commit_clusters(self, clusters: List[CommitCluster]) -> List[str]:
+        """Commit multiple clusters in sequence.
+        
+        Args:
+            clusters: List of CommitCluster objects.
+        
+        Returns:
+            List of commit hashes.
+        """
+        commit_hashes = []
+        
+        for cluster in clusters:
+            try:
+                commit_hash = self.commit_cluster(cluster)
+                commit_hashes.append(commit_hash)
+            except Exception as e:
+                # Log error but continue with next cluster
+                print(f"Error committing cluster: {e}")
+        
+        # Save session for undo support
+        self.git_service.save_session(self.session)
+        
+        return commit_hashes
+
+    def stage_files(self, file_paths: List[str]) -> None:
+        """Stage specific files.
+        
+        Args:
+            file_paths: List of file paths to stage.
+        """
+        self.git_service.stage_files(file_paths)
+
+    def unstage_files(self, file_paths: List[str]) -> None:
+        """Unstage specific files.
+        
+        Args:
+            file_paths: List of file paths to unstage.
+        """
+        self.git_service.unstage_files(file_paths)
+

smart_commit/config.py

@@ -0,0 +1,88 @@
+"""Configuration management for Smart Commit."""
+
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Optional
+import os
+
+try:
+    from dotenv import load_dotenv
+except ImportError:  # pragma: no cover - optional dependency fallback
+    def load_dotenv() -> None:
+        return None
+
+
+load_dotenv()
+
+
+@dataclass
+class Config:
+    """Smart Commit configuration."""
+
+    provider: str = "openrouter"
+    model: str = "anthropic/claude-sonnet"
+    api_key: Optional[str] = None
+    embedding_model: str = "all-MiniLM-L6-v2"
+    max_files_per_commit: int = 8
+    clustering_method: str = "agglomerative"
+    similarity_threshold: float = 0.5
+    interactive: bool = True
+    auto_push: bool = False
+    conventional_commits: bool = True
+    use_local_embeddings: bool = True
+    max_diff_size: int = 100000
+    session_history_dir: str = ".smart_commit"
+
+    @staticmethod
+    def load_from_file(config_path: Path) -> "Config":
+        """Load configuration from YAML."""
+        if not config_path.exists():
+            return Config.from_env()
+
+        try:
+            import yaml
+        except ImportError:
+            return Config.from_env()
+
+        with config_path.open(encoding="utf-8") as file:
+            data = yaml.safe_load(file) or {}
+        env_config = Config.from_env()
+        merged = asdict(env_config)
+        merged.update(data)
+        return Config(**merged)
+
+    @staticmethod
+    def from_env() -> "Config":
+        """Load configuration from environment variables."""
+        return Config(
+            provider=os.getenv("SMART_COMMIT_PROVIDER", "openrouter"),
+            model=os.getenv("SMART_COMMIT_MODEL", "anthropic/claude-sonnet"),
+            api_key=os.getenv("SMART_COMMIT_API_KEY"),
+            embedding_model=os.getenv("SMART_COMMIT_EMBEDDING_MODEL", "all-MiniLM-L6-v2"),
+            max_files_per_commit=int(os.getenv("SMART_COMMIT_MAX_FILES_PER_COMMIT", "8")),
+            clustering_method=os.getenv("SMART_COMMIT_CLUSTERING_METHOD", "agglomerative"),
+            similarity_threshold=float(os.getenv("SMART_COMMIT_SIMILARITY_THRESHOLD", "0.5")),
+            interactive=os.getenv("SMART_COMMIT_INTERACTIVE", "true").lower() != "false",
+            auto_push=os.getenv("SMART_COMMIT_AUTO_PUSH", "false").lower() == "true",
+            conventional_commits=os.getenv("SMART_COMMIT_CONVENTIONAL_COMMITS", "true").lower()
+            != "false",
+            use_local_embeddings=os.getenv("SMART_COMMIT_USE_LOCAL_EMBEDDINGS", "true").lower()
+            != "false",
+        )
+
+    @staticmethod
+    def load() -> "Config":
+        """Load configuration from file, then environment defaults."""
+        return Config.load_from_file(Path.home() / ".smart_commit" / "config.yaml")
+
+    def save_to_file(self, config_path: Path) -> None:
+        """Save configuration as YAML."""
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            import yaml
+
+            with config_path.open("w", encoding="utf-8") as file:
+                yaml.safe_dump(asdict(self), file, default_flow_style=False)
+        except ImportError:
+            lines = [f"{key}: {value}" for key, value in asdict(self).items()]
+            config_path.write_text("\n".join(lines) + "\n", encoding="utf-8")

smart_commit/constants.py

@@ -0,0 +1,92 @@
+"""Constants for Smart Commit."""
+
+from enum import Enum
+from pathlib import Path
+
+# Version
+VERSION = "0.2.0"
+
+# Default configuration
+DEFAULT_EMBEDDING_MODEL = "all-MiniLM-L6-v2"
+DEFAULT_LLM_PROVIDER = "openrouter"
+DEFAULT_LLM_MODEL = "anthropic/claude-sonnet"
+DEFAULT_MAX_FILES_PER_COMMIT = 8
+DEFAULT_SIMILARITY_THRESHOLD = 0.5
+DEFAULT_MAX_DIFF_SIZE = 100000  # chars
+
+# Configuration file locations
+CONFIG_DIR = Path.home() / ".smart_commit"
+CONFIG_FILE = CONFIG_DIR / "config.yaml"
+SESSION_DIR = CONFIG_DIR / "sessions"
+PLUGINS_DIR = CONFIG_DIR / "plugins"
+
+# Weight factors for similarity graph
+SIMILARITY_WEIGHTS = {
+    "semantic": 0.45,      # Embeddings
+    "directory": 0.20,     # Same folder
+    "imports": 0.15,       # Import overlap
+    "symbols": 0.15,       # Symbol overlap
+    "filename": 0.05       # Filename similarity
+}
+
+# Max retries for LLM
+MAX_LLM_RETRIES = 3
+LLM_TIMEOUT = 30  # seconds
+
+# File size limits
+MAX_FILE_DIFF_SIZE = 500000  # 500KB per file
+MAX_TOTAL_DIFF_SIZE = 5000000  # 5MB total
+
+# Clustering
+DEFAULT_CLUSTERING_METHOD = "agglomerative"
+MIN_CLUSTER_SIZE = 1
+MAX_CLUSTER_SIZE = 10
+
+# UI
+PROGRESS_BAR_WIDTH = 40
+MAX_FILES_IN_PREVIEW = 5
+PREVIEW_WRAP_LENGTH = 80
+
+# Commit message
+MAX_COMMIT_TITLE_LENGTH = 72
+MAX_COMMIT_BODY_LENGTH = 100
+
+# Session
+SESSION_HISTORY_MAX = 50
+
+
+class CommitAction(str, Enum):
+    """User actions in preview."""
+    ACCEPT = "a"
+    EDIT = "e"
+    SPLIT = "s"
+    MERGE = "m"
+    DISCARD = "d"
+    SKIP = "k"
+    QUIT = "q"
+
+
+class FileStatus(str, Enum):
+    """Git file status."""
+    ADDED = "A"
+    MODIFIED = "M"
+    DELETED = "D"
+    RENAMED = "R"
+    COPIED = "C"
+    UNTRACKED = "U"
+
+
+class ClusteringMethod(str, Enum):
+    """Clustering algorithm options."""
+    AGGLOMERATIVE = "agglomerative"
+    HDBSCAN = "hdbscan"
+    HEURISTIC = "heuristic"
+
+
+class ConfidenceLevel(str, Enum):
+    """Confidence levels for clustering decisions."""
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+    VERY_HIGH = "very_high"
+

smart_commit/diff_parser.py

@@ -0,0 +1,158 @@
+"""Diff parser for extracting structured information from git diffs."""
+
+import re
+from typing import Optional, List, Tuple
+from .models import FileDiff
+
+
+class DiffParser:
+    """Parses git diffs and extracts structured information."""
+
+    def __init__(self):
+        """Initialize the diff parser."""
+        self.language_keywords = {
+            ".py": ["def ", "class ", "import ", "from "],
+            ".js": ["function ", "class ", "import ", "export "],
+            ".ts": ["interface ", "type ", "class ", "function ", "import "],
+            ".tsx": ["interface ", "function ", "export ", "const ", "import "],
+            ".jsx": ["function ", "export ", "import ", "const "],
+            ".java": ["class ", "public ", "private ", "interface "],
+            ".cpp": ["class ", "void ", "int ", "#include "],
+            ".go": ["func ", "type ", "package ", "import "],
+            ".rs": ["fn ", "struct ", "impl ", "use "],
+            ".rb": ["def ", "class ", "module ", "require "],
+        }
+
+    def parse_diff(self, raw_diff: str, file_path: str) -> List[str]:
+        """Extract meaningful changes from a raw diff.
+        
+        Args:
+            raw_diff: Raw diff content from git.
+            file_path: Path to the file.
+        
+        Returns:
+            List of change descriptions.
+        """
+        if not raw_diff.strip():
+            return []
+        
+        changes = []
+        
+        # Detect file extension
+        file_ext = self._get_file_extension(file_path)
+        
+        # Parse diff lines
+        lines = raw_diff.split('\n')
+        added_lines = [l[1:] for l in lines if l.startswith('+') and not l.startswith('+++')]
+        removed_lines = [l[1:] for l in lines if l.startswith('-') and not l.startswith('---')]
+        
+        # Extract high-level changes
+        if added_lines and not removed_lines:
+            changes.append("Added new content")
+        elif removed_lines and not added_lines:
+            changes.append("Removed content")
+        elif added_lines and removed_lines:
+            changes.append("Modified content")
+        
+        # Detect function/class changes
+        keywords = self.language_keywords.get(file_ext, [])
+        
+        for line in added_lines:
+            for keyword in keywords:
+                if keyword in line:
+                    # Extract the identifier
+                    match = re.search(rf"{keyword}(\w+)", line)
+                    if match:
+                        identifier = match.group(1)
+                        changes.append(f"Added {keyword.strip().rstrip('(')} '{identifier}'")
+                    break
+        
+        for line in removed_lines:
+            for keyword in keywords:
+                if keyword in line:
+                    match = re.search(rf"{keyword}(\w+)", line)
+                    if match:
+                        identifier = match.group(1)
+                        changes.append(f"Removed {keyword.strip().rstrip('(')} '{identifier}'")
+                    break
+        
+        # Count stats
+        num_added = len([l for l in lines if l.startswith('+')])
+        num_removed = len([l for l in lines if l.startswith('-')])
+        
+        if num_added > 0 or num_removed > 0:
+            changes.append(f"{num_added} lines added, {num_removed} lines removed")
+        
+        return changes
+
+    def extract_summary(self, raw_diff: str, file_path: str) -> str:
+        """Extract a one-line summary of changes.
+        
+        Args:
+            raw_diff: Raw diff content from git.
+            file_path: Path to the file.
+        
+        Returns:
+            One-line summary of changes.
+        """
+        changes = self.parse_diff(raw_diff, file_path)
+        
+        if not changes:
+            return "Modified file"
+        
+        # Take the most significant changes
+        primary_changes = [c for c in changes if 'Added' in c or 'Removed' in c]
+        
+        if primary_changes:
+            return primary_changes[0]
+        
+        return changes[0]
+
+    @staticmethod
+    def _get_file_extension(file_path: str) -> str:
+        """Get file extension."""
+        if '.' not in file_path:
+            return ""
+        
+        ext = '.' + file_path.split('.')[-1]
+        return ext
+
+    @staticmethod
+    def get_file_type(file_path: str) -> str:
+        """Determine file type category.
+        
+        Args:
+            file_path: Path to file.
+        
+        Returns:
+            File type category.
+        """
+        file_lower = file_path.lower()
+        
+        # Frontend files
+        if any(x in file_lower for x in ['.jsx', '.tsx', '.vue', '.css', '.scss']):
+            return "frontend"
+        
+        # Backend files
+        if any(x in file_lower for x in ['.py', '.java', '.go', '.rs', '.rb', '.php']):
+            return "backend"
+        
+        # Config/build files
+        if any(x in file_lower for x in ['package.json', 'pyproject.toml', 'requirements.txt', 
+                                           'dockerfile', '.env', 'config.yaml']):
+            return "config"
+        
+        # Test files
+        if 'test' in file_lower or 'spec' in file_lower:
+            return "test"
+        
+        # Documentation
+        if any(x in file_lower for x in ['.md', '.rst', '.txt']):
+            return "docs"
+        
+        # Database/data files
+        if any(x in file_lower for x in ['.sql', '.json', '.xml', '.csv']):
+            return "data"
+        
+        return "other"
+

smart_commit/embeddings/__init__.py

@@ -0,0 +1,7 @@
+"""Embeddings package."""
+
+from .generator import EmbeddingsGenerator
+from .similarity import SimilarityGraph
+
+__all__ = ["EmbeddingsGenerator", "SimilarityGraph"]
+

smart_commit/embeddings/generator.py

@@ -0,0 +1,128 @@
+"""Semantic embeddings generation."""
+
+from typing import List, Optional
+import numpy as np
+
+from ..models import FileDiff, CommitCluster
+from ..logger import get_logger
+from ..constants import DEFAULT_EMBEDDING_MODEL
+from ..cache import cache_manager
+
+logger = get_logger("embeddings.generator")
+
+
+class EmbeddingsGenerator:
+    """Generates semantic embeddings using sentence transformers."""
+
+    def __init__(self, model_name: str = DEFAULT_EMBEDDING_MODEL):
+        """Initialize embeddings generator.
+        
+        Args:
+            model_name: Sentence transformer model name.
+        """
+        self.model_name = model_name
+        self.model = None
+        self._init_model()
+
+    def _init_model(self):
+        """Initialize the embedding model."""
+        try:
+            from sentence_transformers import SentenceTransformer
+            logger.info(f"Loading embedding model: {self.model_name}")
+            self.model = SentenceTransformer(self.model_name)
+            logger.debug(f"Model loaded successfully")
+        except Exception as e:
+            logger.error(f"Failed to load embedding model: {e}")
+            raise
+
+    def generate_embedding(self, text: str) -> Optional[List[float]]:
+        """Generate embedding for text.
+        
+        Args:
+            text: Text to embed.
+        
+        Returns:
+            Embedding vector or None.
+        """
+        if not text or not self.model:
+            return None
+            
+        cached = cache_manager.get("embeddings", text)
+        if cached is not None:
+            return cached
+        
+        try:
+            embeddings = self.model.encode(text, convert_to_numpy=True)
+            result = embeddings.tolist()
+            cache_manager.set("embeddings", text, result)
+            return result
+        except Exception as e:
+            logger.error(f"Failed to generate embedding: {e}")
+            return None
+
+    def generate_file_embedding(self, file_diff: FileDiff) -> Optional[List[float]]:
+        """Generate embedding for a file diff.
+        
+        Args:
+            file_diff: FileDiff object.
+        
+        Returns:
+            Embedding vector or None.
+        """
+        # Combine multiple text sources for richer embedding
+        text_parts = [
+            file_diff.file_path,
+            file_diff.status,
+            file_diff.summary or "",
+        ]
+        
+        text = " ".join(text_parts).strip()
+        
+        if not text:
+            return None
+        
+        return self.generate_embedding(text)
+
+    def compute_similarity(self, embedding1: List[float], 
+                          embedding2: List[float]) -> float:
+        """Compute cosine similarity between two embeddings.
+        
+        Args:
+            embedding1: First embedding.
+            embedding2: Second embedding.
+        
+        Returns:
+            Similarity score (0-1).
+        """
+        if not embedding1 or not embedding2:
+            return 0.0
+        
+        arr1 = np.array(embedding1)
+        arr2 = np.array(embedding2)
+        
+        # Cosine similarity
+        dot = np.dot(arr1, arr2)
+        norm1 = np.linalg.norm(arr1)
+        norm2 = np.linalg.norm(arr2)
+        
+        if norm1 == 0 or norm2 == 0:
+            return 0.0
+        
+        return float(dot / (norm1 * norm2))
+
+    def compute_cluster_similarity(self, cluster1: CommitCluster,
+                                   cluster2: CommitCluster) -> float:
+        """Compute similarity between two clusters.
+        
+        Args:
+            cluster1: First cluster.
+            cluster2: Second cluster.
+        
+        Returns:
+            Similarity score (0-1).
+        """
+        if not cluster1.embedding or not cluster2.embedding:
+            return 0.0
+        
+        return self.compute_similarity(cluster1.embedding, cluster2.embedding)
+