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

smart_commit/embeddings/similarity.py

@@ -0,0 +1,159 @@
+"""Similarity graph for commit clustering."""
+
+from typing import List, Dict, Optional
+import numpy as np
+from dataclasses import dataclass
+
+from ..models import FileDiff
+from ..constants import SIMILARITY_WEIGHTS
+from ..logger import get_logger
+from .generator import EmbeddingsGenerator
+from ..analysis.dependency_graph import DependencyGraph
+
+logger = get_logger("embeddings.similarity")
+
+
+@dataclass
+class SimilarityScore:
+    """Structured breakdown of similarity between two files."""
+    semantic: float = 0.0
+    dependency: float = 0.0
+    imports: float = 0.0
+    symbols: float = 0.0
+    directory: float = 0.0
+    filename: float = 0.0
+    total: float = 0.0
+    details: List[str] = None
+
+    def __post_init__(self):
+        if self.details is None:
+            self.details = []
+
+
+class SimilarityGraph:
+    """Builds a weighted similarity graph between files."""
+
+    def __init__(self, embeddings_gen: EmbeddingsGenerator, dep_graph: Optional[DependencyGraph] = None, weights: Optional[Dict[str, float]] = None):
+        """Initialize similarity graph."""
+        self.embeddings_gen = embeddings_gen
+        self.dep_graph = dep_graph
+        self.weights = weights or SIMILARITY_WEIGHTS.copy()
+        
+        # Adjust weights if dependency graph is provided
+        if "dependency" not in self.weights:
+            self.weights["dependency"] = 0.15
+            # Reduce others proportionally to sum to 1.0, 
+            # but simpler to just normalize at the end.
+            total_weight = sum(self.weights.values())
+            for k in self.weights:
+                self.weights[k] /= total_weight
+
+    def build_graph(self, file_diffs: List[FileDiff]) -> np.ndarray:
+        """Build similarity matrix for files."""
+        n = len(file_diffs)
+        matrix = np.zeros((n, n))
+        
+        for i in range(n):
+            matrix[i][i] = 1.0
+            for j in range(i + 1, n):
+                score = self.compute_file_similarity(file_diffs[i], file_diffs[j])
+                matrix[i][j] = score.total
+                matrix[j][i] = score.total
+        
+        return matrix
+
+    def compute_file_similarity(self, file1: FileDiff, file2: FileDiff) -> SimilarityScore:
+        """Compute structured weighted similarity between two files."""
+        score = SimilarityScore()
+        
+        # Handle renames logically - if it's a rename of the same logical file, score high
+        if file1.is_renamed and file1.old_file_path == file2.file_path:
+            score.total = 1.0
+            score.details.append("Renamed file match")
+            return score
+        if file2.is_renamed and file2.old_file_path == file1.file_path:
+            score.total = 1.0
+            score.details.append("Renamed file match")
+            return score
+
+        # 1. Semantic similarity
+        emb1 = self.embeddings_gen.generate_file_embedding(file1)
+        emb2 = self.embeddings_gen.generate_file_embedding(file2)
+        if emb1 and emb2:
+            score.semantic = self.embeddings_gen.compute_similarity(emb1, emb2)
+            if score.semantic > 0.6:
+                score.details.append("High semantic similarity")
+                
+        # 2. Dependency Graph distance
+        if self.dep_graph:
+            dist = self.dep_graph.get_distance(file1.file_path, file2.file_path)
+            if dist == 1.0:
+                score.dependency = 1.0
+                score.details.append("Direct dependency")
+            elif dist == 2.0:
+                score.dependency = 0.5
+                score.details.append("Close dependency")
+
+        # 3. Directory similarity
+        dir1 = self._get_directory(file1.file_path)
+        dir2 = self._get_directory(file2.file_path)
+        
+        if dir1 == dir2 and dir1:
+            score.directory = 1.0
+            score.details.append("Same subsystem")
+        elif dir1 and dir2 and (dir1.startswith(dir2) or dir2.startswith(dir1)):
+            score.directory = 0.5
+            score.details.append("Related subsystem")
+            
+        # 4. Import & Symbol overlap
+        sym1 = file1.extracted_symbols
+        sym2 = file2.extracted_symbols
+        
+        imports1 = set(sym1.imported)
+        imports2 = set(sym2.imported)
+        if imports1 and imports2:
+            overlap = len(imports1 & imports2)
+            total = len(imports1 | imports2)
+            score.imports = overlap / total
+            if score.imports > 0.2:
+                score.details.append("Shared imports")
+                
+        all_sym1 = set(sym1.added + sym1.modified + sym1.removed + sym1.classes + sym1.functions)
+        all_sym2 = set(sym2.added + sym2.modified + sym2.removed + sym2.classes + sym2.functions)
+        if all_sym1 and all_sym2:
+            overlap = len(all_sym1 & all_sym2)
+            total = len(all_sym1 | all_sym2)
+            score.symbols = overlap / total
+            if score.symbols > 0.1:
+                score.details.append("Shared symbols")
+                
+        # 5. Filename similarity
+        name1 = file1.file_path.split('/')[-1].lower()
+        name2 = file2.file_path.split('/')[-1].lower()
+        if name1 == name2:
+            score.filename = 1.0
+        elif name1 in name2 or name2 in name1:
+            score.filename = 0.5
+            
+        # Compute total
+        total = (
+            score.semantic * self.weights.get("semantic", 0.45) +
+            score.dependency * self.weights.get("dependency", 0.15) +
+            score.directory * self.weights.get("directory", 0.20) +
+            score.imports * self.weights.get("imports", 0.15) +
+            score.symbols * self.weights.get("symbols", 0.15) +
+            score.filename * self.weights.get("filename", 0.05)
+        )
+        
+        # Re-normalize if weights sum > 1.0
+        weight_sum = sum(self.weights.values())
+        if weight_sum > 0:
+            total /= weight_sum
+            
+        score.total = min(1.0, total)
+        return score
+
+    @staticmethod
+    def _get_directory(file_path: str) -> str:
+        parts = file_path.split('/')
+        return '/'.join(parts[:-1]) if len(parts) > 1 else ""

smart_commit/embeddings.py

@@ -0,0 +1,108 @@
+"""Embeddings generator for semantic similarity."""
+
+from typing import List, Optional
+import numpy as np
+from .models import FileDiff, CommitCluster
+
+
+class EmbeddingsGenerator:
+    """Generates embeddings for semantic similarity."""
+
+    def __init__(self, use_local: bool = True):
+        """Initialize embeddings generator.
+        
+        Args:
+            use_local: Use local sentence transformers (True) or API-based (False).
+        """
+        self.use_local = use_local
+        self.model = None
+        
+        if use_local:
+            self._init_local_model()
+
+    def _init_local_model(self):
+        """Initialize local sentence transformer model."""
+        try:
+            from sentence_transformers import SentenceTransformer
+            self.model = SentenceTransformer('all-MiniLM-L6-v2')
+        except Exception as e:
+            raise RuntimeError(f"Failed to load embedding model: {e}")
+
+    def generate_embedding(self, text: str) -> Optional[List[float]]:
+        """Generate embedding for a text string.
+        
+        Args:
+            text: Text to embed.
+        
+        Returns:
+            Embedding vector as list of floats.
+        """
+        if not text or not self.model:
+            return None
+        
+        try:
+            embeddings = self.model.encode(text, convert_to_numpy=True)
+            return embeddings.tolist()
+        except Exception:
+            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.
+        """
+        # Combine file path and summary for embedding
+        text_parts = [
+            file_diff.file_path,
+            file_diff.summary or ""
+        ]
+        
+        text = " ".join(text_parts).strip()
+        
+        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 vector.
+            embedding2: Second embedding vector.
+        
+        Returns:
+            Similarity score (0-1).
+        """
+        if not embedding1 or not embedding2:
+            return 0.0
+        
+        arr1 = np.array(embedding1)
+        arr2 = np.array(embedding2)
+        
+        # Compute cosine similarity
+        dot_product = 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_product / (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)
+

smart_commit/exceptions.py

@@ -0,0 +1,102 @@
+"""Custom exceptions for Smart Commit."""
+
+
+class SmartCommitException(Exception):
+    """Base exception for Smart Commit."""
+    pass
+
+
+class GitException(SmartCommitException):
+    """Git-related errors."""
+    pass
+
+
+class InvalidRepositoryError(GitException):
+    """Raised when repository is invalid or not found."""
+    pass
+
+
+class NoChangesError(GitException):
+    """Raised when no changes are found."""
+    pass
+
+
+class StagingError(GitException):
+    """Raised when staging files fails."""
+    pass
+
+
+class CommitError(GitException):
+    """Raised when commit creation fails."""
+    pass
+
+
+class ConfigurationError(SmartCommitException):
+    """Configuration-related errors."""
+    pass
+
+
+class InvalidConfigurationError(ConfigurationError):
+    """Raised when configuration is invalid."""
+    pass
+
+
+class LLMException(SmartCommitException):
+    """LLM-related errors."""
+    pass
+
+
+class LLMTimeoutError(LLMException):
+    """Raised when LLM request times out."""
+    pass
+
+
+class LLMRateLimitError(LLMException):
+    """Raised when LLM rate limit is exceeded."""
+    pass
+
+
+class AnalysisException(SmartCommitException):
+    """Analysis-related errors."""
+    pass
+
+
+class DiffParsingError(AnalysisException):
+    """Raised when diff parsing fails."""
+    pass
+
+
+class ClusteringException(SmartCommitException):
+    """Clustering-related errors."""
+    pass
+
+
+class PreviewException(SmartCommitException):
+    """Preview UI errors."""
+    pass
+
+
+class PluginException(SmartCommitException):
+    """Plugin system errors."""
+    pass
+
+
+class PluginLoadError(PluginException):
+    """Raised when plugin fails to load."""
+    pass
+
+
+class UndoException(SmartCommitException):
+    """Undo operation errors."""
+    pass
+
+
+class SafetyCheckFailed(SmartCommitException):
+    """Raised when safety check fails."""
+    pass
+
+
+class UserCancelled(SmartCommitException):
+    """Raised when user cancels operation."""
+    pass
+

smart_commit/execution/__init__.py

@@ -0,0 +1,6 @@
+"""Execution package."""
+
+from .committer import Committer
+
+__all__ = ["Committer"]
+

smart_commit/execution/committer.py

@@ -0,0 +1,102 @@
+"""Commit execution and session management."""
+
+from ..models import CommitCluster, SessionInfo
+from ..git import GitService
+from ..utils import generate_session_id, get_timestamp
+from ..logger import get_logger
+
+logger = get_logger("execution.committer")
+
+
+class Committer:
+    """Executes commits and manages sessions."""
+
+    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:
+        """Commit a cluster of files.
+        
+        Args:
+            cluster: CommitCluster to commit.
+        
+        Returns:
+            Commit hash.
+        """
+        file_paths = [f.file_path for f in cluster.files]
+        
+        # Stage files
+        logger.info(f"Staging {len(file_paths)} file(s)...")
+        self.git_service.stage_files(file_paths)
+        
+        # Create commit
+        message = cluster.message or "Automatic commit"
+        logger.info(f"Creating commit: {message}")
+        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 sequentially.
+        
+        Args:
+            clusters: List of CommitCluster objects.
+        
+        Returns:
+            List of commit hashes.
+        """
+        commit_hashes = []
+
+        try:
+            for idx, cluster in enumerate(clusters, 1):
+                logger.info(f"Processing cluster {idx}/{len(clusters)}...")
+                commit_hash = self.commit_cluster(cluster)
+                commit_hashes.append(commit_hash)
+        except Exception as exc:
+            if commit_hashes:
+                logger.error("Commit failed; rolling back %s created commit(s)", len(commit_hashes))
+                self.git_service.reset_soft(len(commit_hashes))
+            raise exc
+
+        if commit_hashes:
+            self.git_service.save_session(self.session)
+        logger.info(f"Session saved: {self.session.session_id}")
+        
+        return commit_hashes
+
+    def dry_run(self, clusters: list[CommitCluster]) -> list[dict]:
+        """Simulate commits without actually creating them.
+        
+        Args:
+            clusters: List of CommitCluster objects.
+        
+        Returns:
+            List of simulated commit info.
+        """
+        simulated = []
+        
+        for idx, cluster in enumerate(clusters, 1):
+            simulated.append({
+                "number": idx,
+                "message": cluster.message or "Automatic commit",
+                "files": len(cluster.files),
+                "commit_type": cluster.commit_type.value if cluster.commit_type else "chore"
+            })
+        
+        logger.info(f"Dry run: would create {len(simulated)} commit(s)")
+        return simulated
+

smart_commit/git/__init__.py

@@ -0,0 +1,8 @@
+"""Git operations package."""
+
+from .service import GitService
+from .scanner import RepositoryScanner
+from .safety import SafetyChecker
+
+__all__ = ["GitService", "RepositoryScanner", "SafetyChecker"]
+

smart_commit/git/safety.py

@@ -0,0 +1,75 @@
+"""Safety checks before commit execution."""
+
+from typing import List
+from pathlib import Path
+
+from ..logger import get_logger
+from ..exceptions import SafetyCheckFailed
+
+logger = get_logger("git.safety")
+
+
+class SafetyChecker:
+    """Performs safety checks before execution."""
+
+    @staticmethod
+    def check_branch_protected(repo_path: Path, branch: str) -> bool:
+        """Check if branch appears to be protected.
+        
+        Args:
+            repo_path: Path to repository.
+            branch: Branch name.
+        
+        Returns:
+            True if branch is likely protected.
+        """
+        protected_branches = {'main', 'master', 'production', 'release'}
+        return branch.lower() in protected_branches
+
+    @staticmethod
+    def check_uncommitted_changes(changed_files: int) -> bool:
+        """Check if there are too many changes.
+        
+        Args:
+            changed_files: Number of changed files.
+        
+        Returns:
+            True if change count is reasonable.
+        """
+        # Warn if more than 100 files
+        return changed_files <= 100
+
+    @staticmethod
+    def check_commit_messages(messages: List[str]) -> bool:
+        """Validate commit messages.
+        
+        Args:
+            messages: List of commit messages.
+        
+        Returns:
+            True if all messages are valid.
+        """
+        for msg in messages:
+            if not msg or len(msg.strip()) == 0:
+                return False
+            if len(msg) > 100:
+                return False
+        
+        return True
+
+    @staticmethod
+    def check_file_paths(file_paths: List[str]) -> bool:
+        """Check if file paths are valid.
+        
+        Args:
+            file_paths: List of file paths.
+        
+        Returns:
+            True if all paths are valid.
+        """
+        for path in file_paths:
+            if '..' in path or path.startswith('/'):
+                return False
+        
+        return True
+