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

smart_commit/logger.py

@@ -0,0 +1,99 @@
+"""Logging configuration for Smart Commit."""
+
+import logging
+import sys
+from pathlib import Path
+from typing import Optional
+from datetime import datetime
+
+from .constants import CONFIG_DIR
+
+
+class SmartCommitFormatter(logging.Formatter):
+    """Custom formatter for Smart Commit logs."""
+
+    COLORS = {
+        'DEBUG': '\033[36m',      # Cyan
+        'INFO': '\033[32m',       # Green
+        'WARNING': '\033[33m',    # Yellow
+        'ERROR': '\033[31m',      # Red
+        'CRITICAL': '\033[41m',   # Red background
+    }
+    RESET = '\033[0m'
+
+    def format(self, record):
+        """Format log record with colors."""
+        if sys.stderr.isatty():
+            levelname = record.levelname
+            color = self.COLORS.get(levelname, '')
+            record.levelname = f"{color}{levelname}{self.RESET}"
+        
+        return super().format(record)
+
+
+def setup_logging(verbose: bool = False, log_file: Optional[Path] = None) -> logging.Logger:
+    """Set up logging configuration.
+    
+    Args:
+        verbose: Enable verbose logging.
+        log_file: Optional log file path.
+    
+    Returns:
+        Configured logger.
+    """
+    logger = logging.getLogger("smart_commit")
+    
+    # Clear existing handlers
+    logger.handlers.clear()
+    
+    # Set level
+    level = logging.DEBUG if verbose else logging.INFO
+    logger.setLevel(level)
+    
+    # Console handler
+    console_handler = logging.StreamHandler(sys.stderr)
+    console_handler.setLevel(level)
+    
+    formatter = SmartCommitFormatter(
+        '%(levelname)s: %(message)s'
+    )
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+    
+    # File handler (optional)
+    if log_file:
+        log_file.parent.mkdir(parents=True, exist_ok=True)
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setLevel(logging.DEBUG)
+        
+        file_formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        file_handler.setFormatter(file_formatter)
+        logger.addHandler(file_handler)
+    
+    return logger
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Get a logger instance.
+    
+    Args:
+        name: Logger name.
+    
+    Returns:
+        Logger instance.
+    """
+    return logging.getLogger(f"smart_commit.{name}")
+
+
+def get_session_log_file() -> Path:
+    """Get the session log file path.
+    
+    Returns:
+        Path to session log file.
+    """
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    return CONFIG_DIR / "logs" / f"session_{timestamp}.log"
+

smart_commit/models.py

@@ -0,0 +1,73 @@
+from enum import Enum
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+class CommitType(str, Enum):
+    """Conventional Commit types."""
+    FEAT = "feat"
+    FIX = "fix"
+    DOCS = "docs"
+    STYLE = "style"
+    REFACTOR = "refactor"
+    PERF = "perf"
+    TEST = "test"
+    CHORE = "chore"
+    CI = "ci"
+    BUILD = "build"
+
+
+@dataclass
+class SymbolExtraction:
+    """Structured symbols extracted from a file."""
+    added: list[str] = field(default_factory=list)
+    removed: list[str] = field(default_factory=list)
+    modified: list[str] = field(default_factory=list)
+    imported: list[str] = field(default_factory=list)
+    exported: list[str] = field(default_factory=list)
+    classes: list[str] = field(default_factory=list)
+    functions: list[str] = field(default_factory=list)
+
+
+@dataclass
+class FileDiff:
+    """Represents a single file's diff."""
+
+    file_path: str
+    status: str
+    additions: int
+    deletions: int
+    raw_diff: str
+    old_file_path: Optional[str] = None
+    is_renamed: bool = False
+    summary: Optional[str] = None
+    symbols: list[str] = field(default_factory=list) # Deprecated, keep for backwards compat
+    imports: list[str] = field(default_factory=list) # Deprecated
+    extracted_symbols: SymbolExtraction = field(default_factory=SymbolExtraction)
+
+
+@dataclass
+class CommitCluster:
+    """Represents a group of related file changes."""
+
+    id: str
+    files: list[FileDiff] = field(default_factory=list)
+    summary: Optional[str] = None
+    embedding: Optional[list[float]] = None
+    commit_type: Optional[CommitType] = None
+    scope: Optional[str] = None
+    message: Optional[str] = None
+    description: Optional[str] = None
+    confidence: float = 0.5
+    reason: str = ""
+
+
+@dataclass
+class SessionInfo:
+    """Session tracking for undo support."""
+
+    session_id: str
+    commit_hashes: list[str] = field(default_factory=list)
+    timestamp: str = ""
+    branch: str = ""
+    repository_path: str = ""

smart_commit/plugins/__init__.py

@@ -0,0 +1,6 @@
+"""Plugin system package."""
+
+from .base import Plugin, PluginRegistry
+
+__all__ = ["Plugin", "PluginRegistry"]
+

smart_commit/plugins/base.py

@@ -0,0 +1,135 @@
+"""Plugin base classes and registry."""
+
+from abc import ABC, abstractmethod
+from typing import List, Dict, Optional, Set
+from pathlib import Path
+
+from ..models import FileDiff, CommitCluster
+from ..logger import get_logger
+
+logger = get_logger("plugins.base")
+
+
+class Plugin(ABC):
+    """Base class for Smart Commit plugins."""
+
+    name: str = "BasePlugin"
+    version: str = "0.1.0"
+    description: str = "Base plugin"
+
+    @abstractmethod
+    def get_ignored_files(self) -> List[str]:
+        """Get list of files to ignore.
+        
+        Returns:
+            List of glob patterns.
+        """
+        pass
+
+    @abstractmethod
+    def get_commit_hints(self, file_diffs: List[FileDiff]) -> Dict[str, str]:
+        """Get hints for clustering based on framework knowledge.
+        
+        Args:
+            file_diffs: List of changed files.
+        
+        Returns:
+            Dict of file_path -> hint strings.
+        """
+        pass
+
+    def parse_symbols(self, file_path: str, content: str) -> List[str]:
+        """Parse symbols from file content.
+        
+        Args:
+            file_path: Path to file.
+            content: File content.
+        
+        Returns:
+            List of symbol names.
+        """
+        return []
+
+    def should_group_files(self, file1: str, file2: str) -> Optional[bool]:
+        """Determine if two files should be grouped together.
+        
+        Args:
+            file1: First file path.
+            file2: Second file path.
+        
+        Returns:
+            True to group, False to separate, None to let other logic decide.
+        """
+        return None
+
+
+class PluginRegistry:
+    """Registry for managing plugins."""
+
+    def __init__(self):
+        """Initialize plugin registry."""
+        self.plugins: Dict[str, Plugin] = {}
+        self._register_default_plugins()
+
+    def _register_default_plugins(self):
+        """Register built-in plugins."""
+        try:
+            from .react import ReactPlugin
+            self.register(ReactPlugin())
+        except ImportError:
+            logger.debug("Failed to load ReactPlugin")
+            
+        try:
+            from .django import DjangoPlugin
+            self.register(DjangoPlugin())
+        except ImportError:
+            logger.debug("Failed to load DjangoPlugin")
+            
+        try:
+            from .fastapi import FastAPIPlugin
+            self.register(FastAPIPlugin())
+        except ImportError:
+            logger.debug("Failed to load FastAPIPlugin")
+            
+        logger.debug("Default plugins registered")
+
+    def register(self, plugin: Plugin):
+        """Register a plugin.
+        
+        Args:
+            plugin: Plugin instance.
+        """
+        self.plugins[plugin.name.lower()] = plugin
+        logger.info(f"Plugin registered: {plugin.name}")
+
+    def get_plugin(self, name: str) -> Optional[Plugin]:
+        """Get plugin by name.
+        
+        Args:
+            name: Plugin name.
+        
+        Returns:
+            Plugin instance or None.
+        """
+        return self.plugins.get(name.lower())
+
+    def list_plugins(self) -> List[str]:
+        """List all registered plugins.
+        
+        Returns:
+            List of plugin names.
+        """
+        return list(self.plugins.keys())
+
+    def get_all_ignored_files(self) -> Set[str]:
+        """Get all ignored files from all plugins.
+        
+        Returns:
+            Set of glob patterns.
+        """
+        all_ignored = set()
+        
+        for plugin in self.plugins.values():
+            all_ignored.update(plugin.get_ignored_files())
+        
+        return all_ignored

smart_commit/plugins/django.py

@@ -0,0 +1,40 @@
+"""Django plugin for Smart Commit."""
+
+from typing import List, Dict
+from .base import Plugin
+from ..models import FileDiff
+
+class DjangoPlugin(Plugin):
+    """Plugin for Django projects."""
+
+    name = "Django"
+    version = "0.1.0"
+    description = "Django models, views, and migrations grouping"
+
+    def get_ignored_files(self) -> List[str]:
+        """Ignore common Django files."""
+        return [
+            "venv/**",
+            ".venv/**",
+            "__pycache__/**",
+            "*.pyc",
+            "db.sqlite3"
+        ]
+
+    def get_commit_hints(self, file_diffs: List[FileDiff]) -> Dict[str, str]:
+        """Provide Django-specific hints."""
+        hints = {}
+        
+        for file_diff in file_diffs:
+            path = file_diff.file_path.lower()
+            
+            if "migrations" in path:
+                hints[file_diff.file_path] = "migrations"
+            elif "models.py" in path:
+                hints[file_diff.file_path] = "models"
+            elif "views.py" in path:
+                hints[file_diff.file_path] = "views"
+            elif "tests.py" in path:
+                hints[file_diff.file_path] = "tests"
+        
+        return hints

smart_commit/plugins/fastapi.py

@@ -0,0 +1,39 @@
+"""FastAPI plugin for Smart Commit."""
+
+from typing import List, Dict
+from .base import Plugin
+from ..models import FileDiff
+
+class FastAPIPlugin(Plugin):
+    """Plugin for FastAPI projects."""
+
+    name = "FastAPI"
+    version = "0.1.0"
+    description = "FastAPI routers, dependencies, and schemas grouping"
+
+    def get_ignored_files(self) -> List[str]:
+        """Ignore common Python files."""
+        return [
+            "venv/**",
+            ".venv/**",
+            "__pycache__/**",
+            "*.pyc"
+        ]
+
+    def get_commit_hints(self, file_diffs: List[FileDiff]) -> Dict[str, str]:
+        """Provide FastAPI-specific hints."""
+        hints = {}
+        
+        for file_diff in file_diffs:
+            path = file_diff.file_path.lower()
+            
+            if "router" in path or "api" in path:
+                hints[file_diff.file_path] = "routers"
+            elif "schemas.py" in path or "models.py" in path:
+                hints[file_diff.file_path] = "schemas"
+            elif "dependencies.py" in path or "deps.py" in path:
+                hints[file_diff.file_path] = "dependencies"
+            elif "services.py" in path:
+                hints[file_diff.file_path] = "services"
+        
+        return hints

smart_commit/plugins/react.py

@@ -0,0 +1,49 @@
+"""React plugin for Smart Commit."""
+
+from typing import List, Dict, Optional
+from .base import Plugin
+from ..models import FileDiff
+
+class ReactPlugin(Plugin):
+    """Plugin for React/JSX projects."""
+
+    name = "React"
+    version = "0.1.0"
+    description = "React component and style grouping"
+
+    def get_ignored_files(self) -> List[str]:
+        """Ignore common React build files."""
+        return [
+            "node_modules/**",
+            "build/**",
+            "dist/**",
+            ".next/**",
+            "coverage/**"
+        ]
+
+    def get_commit_hints(self, file_diffs: List[FileDiff]) -> Dict[str, str]:
+        """Provide React-specific hints."""
+        hints = {}
+        
+        for file_diff in file_diffs:
+            path = file_diff.file_path.lower()
+            
+            if ".test." in path or ".spec." in path:
+                hints[file_diff.file_path] = "test"
+            elif ".module.css" in path or ".module.scss" in path:
+                hints[file_diff.file_path] = "styles"
+            elif "component" in path or path.endswith(".jsx") or path.endswith(".tsx"):
+                hints[file_diff.file_path] = "component"
+        
+        return hints
+
+    def should_group_files(self, file1: str, file2: str) -> Optional[bool]:
+        """Group component with its styles."""
+        f1_base = file1.rsplit('.', 1)[0]
+        f2_base = file2.rsplit('.', 1)[0]
+        
+        if f1_base == f2_base:
+            # Same base name (e.g., Button.tsx and Button.module.css)
+            return True
+        
+        return None

smart_commit/preview/__init__.py

@@ -0,0 +1,6 @@
+"""Preview and UI package."""
+
+from .renderer import PreviewRenderer
+from .editor import InteractiveEditor
+
+__all__ = ["PreviewRenderer", "InteractiveEditor"]

smart_commit/preview/editor.py

@@ -0,0 +1,224 @@
+"""Interactive editor for adjusting commit clusters."""
+
+import uuid
+from typing import List, Optional
+
+from ..models import CommitCluster, FileDiff
+from .renderer import PreviewRenderer
+
+try:
+    from rich.prompt import Prompt, Confirm
+    from rich.console import Console
+except ImportError:
+    Prompt = None
+    Confirm = None
+    Console = None
+
+class InteractiveEditor:
+    """Provides a command loop to interactively edit commit clusters."""
+
+    def __init__(self, clusters: List[CommitCluster], total_files: int, renderer: PreviewRenderer):
+        self.clusters = clusters
+        self.total_files = total_files
+        self.renderer = renderer
+        self.console = Console() if Console else None
+
+    def edit(self) -> str:
+        """Run the interactive loop.
+        
+        Returns:
+            'y' to proceed, 'n' to cancel, 'd' for dry-run.
+        """
+        while True:
+            self.renderer.render_clusters(self.clusters, self.total_files)
+            
+            if Prompt:
+                action = Prompt.ask(
+                    "Action",
+                    choices=["y", "n", "e", "s", "m", "v", "d", "q"],
+                    default="y",
+                    show_choices=False
+                )
+                # Display choices separately for clarity if needed, but standard prompt is fine
+                # Prompt loop: y=accept, n=cancel, e=edit, s=split, m=merge, v=move, d=delete, q=quit
+            else:
+                action = input("\nAction [y] Accept [e] Edit msg [s] Split [m] Merge [v] Move file [d] Delete file [q] Quit: ").lower().strip()
+
+            if action in {"y", "n", "q"}:
+                return action if action in {"y", "n"} else "n"
+            
+            if action == "e":
+                self._action_edit_messages()
+            elif action == "s":
+                self._action_split()
+            elif action == "m":
+                self._action_merge()
+            elif action == "v":
+                self._action_move()
+            elif action == "d":
+                self._action_delete()
+
+    def _action_edit_messages(self):
+        """Edit commit messages inline."""
+        for index, cluster in enumerate(self.clusters, 1):
+            current = cluster.message or cluster.summary or "chore: update files"
+            new_message = input(f"Commit {index} message [{current}]: ").strip()
+            if new_message:
+                cluster.message = new_message
+
+    def _get_cluster_index(self, prompt_text: str) -> Optional[int]:
+        """Helper to get a valid cluster index."""
+        try:
+            val = input(prompt_text).strip()
+            if not val:
+                return None
+            idx = int(val) - 1
+            if 0 <= idx < len(self.clusters):
+                return idx
+            print("Invalid cluster number.")
+            return None
+        except ValueError:
+            print("Please enter a valid number.")
+            return None
+
+    def _action_split(self):
+        """Split a cluster by moving selected files into a new cluster."""
+        idx = self._get_cluster_index("Cluster number to split: ")
+        if idx is None:
+            return
+            
+        cluster = self.clusters[idx]
+        if len(cluster.files) <= 1:
+            print("Cannot split a cluster with 1 or 0 files.")
+            return
+
+        print("Files in cluster:")
+        for i, f in enumerate(cluster.files, 1):
+            print(f"  {i}. {f.file_path}")
+            
+        choices = input("Enter file numbers to move to new cluster (comma separated): ").strip()
+        if not choices:
+            return
+            
+        try:
+            file_indices = [int(c.strip()) - 1 for c in choices.split(",")]
+        except ValueError:
+            print("Invalid input.")
+            return
+            
+        files_to_move = []
+        keep_files = []
+        for i, f in enumerate(cluster.files):
+            if i in file_indices:
+                files_to_move.append(f)
+            else:
+                keep_files.append(f)
+                
+        if not files_to_move or not keep_files:
+            print("Must leave at least one file in the original cluster.")
+            return
+            
+        cluster.files = keep_files
+        
+        new_cluster = CommitCluster(
+            id=str(uuid.uuid4()),
+            files=files_to_move,
+            reason="Manually split by user",
+            confidence=1.0
+        )
+        self.clusters.append(new_cluster)
+        print("Cluster split.")
+
+    def _action_merge(self):
+        """Merge two clusters."""
+        if len(self.clusters) < 2:
+            print("Not enough clusters to merge.")
+            return
+            
+        idx1 = self._get_cluster_index("First cluster number to merge: ")
+        if idx1 is None: return
+        idx2 = self._get_cluster_index("Second cluster number to merge: ")
+        if idx2 is None: return
+        
+        if idx1 == idx2:
+            print("Cannot merge a cluster with itself.")
+            return
+            
+        c1 = self.clusters[idx1]
+        c2 = self.clusters[idx2]
+        
+        c1.files.extend(c2.files)
+        c1.reason = "Manually merged by user"
+        c1.confidence = 1.0
+        
+        self.clusters.pop(idx2)
+        print("Clusters merged.")
+
+    def _action_move(self):
+        """Move a file from one cluster to another."""
+        if len(self.clusters) < 2:
+            print("Not enough clusters to move files between.")
+            return
+            
+        src_idx = self._get_cluster_index("Source cluster number: ")
+        if src_idx is None: return
+        
+        cluster = self.clusters[src_idx]
+        if not cluster.files:
+            return
+            
+        print("Files in source cluster:")
+        for i, f in enumerate(cluster.files, 1):
+            print(f"  {i}. {f.file_path}")
+            
+        try:
+            f_idx = int(input("File number to move: ").strip()) - 1
+            if not (0 <= f_idx < len(cluster.files)):
+                print("Invalid file number.")
+                return
+        except ValueError:
+            print("Invalid input.")
+            return
+            
+        tgt_idx = self._get_cluster_index("Target cluster number: ")
+        if tgt_idx is None or tgt_idx == src_idx:
+            print("Invalid target.")
+            return
+            
+        file_to_move = cluster.files.pop(f_idx)
+        self.clusters[tgt_idx].files.append(file_to_move)
+        
+        # Cleanup empty clusters
+        if not cluster.files:
+            self.clusters.pop(src_idx)
+            
+        print("File moved.")
+
+    def _action_delete(self):
+        """Remove a file from the commit process."""
+        src_idx = self._get_cluster_index("Cluster number containing file: ")
+        if src_idx is None: return
+        
+        cluster = self.clusters[src_idx]
+        if not cluster.files: return
+        
+        print("Files in cluster:")
+        for i, f in enumerate(cluster.files, 1):
+            print(f"  {i}. {f.file_path}")
+            
+        try:
+            f_idx = int(input("File number to delete: ").strip()) - 1
+            if not (0 <= f_idx < len(cluster.files)):
+                print("Invalid file number.")
+                return
+        except ValueError:
+            print("Invalid input.")
+            return
+            
+        cluster.files.pop(f_idx)
+        self.total_files -= 1
+        
+        if not cluster.files:
+            self.clusters.pop(src_idx)
+            
+        print("File removed from commits.")