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

smart_commit/preview/renderer.py

@@ -0,0 +1,94 @@
+"""Preview renderer with Rich enhancement and plain-text fallback."""
+
+from ..constants import MAX_FILES_IN_PREVIEW
+from ..models import CommitCluster
+
+try:
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.table import Table
+    from rich.tree import Tree
+except ImportError:  # pragma: no cover - exercised only without optional UI dependency
+    Console = None
+    Panel = None
+    Table = None
+    Tree = None
+
+
+class PreviewRenderer:
+    """Renders commit proposals and small interactive prompts."""
+
+    def __init__(self) -> None:
+        self.console = Console() if Console else None
+
+    def render_clusters(self, clusters: list[CommitCluster], total_files: int) -> None:
+        """Render all clusters for review."""
+        if self.console:
+            self._render_rich(clusters, total_files)
+        else:
+            self._render_plain(clusters, total_files)
+
+    def _render_rich(self, clusters: list[CommitCluster], total_files: int) -> None:
+        self.console.print()
+        self.console.print(f"[bold cyan]Smart Commit Preview[/bold cyan] - {len(clusters)} commit(s)")
+        self.console.print()
+
+        for index, cluster in enumerate(clusters, 1):
+            message = cluster.message or cluster.summary or "chore: update files"
+            tree = Tree(f"[bold]{message}[/bold]")
+            for file_diff in cluster.files[:MAX_FILES_IN_PREVIEW]:
+                label = f"{file_diff.status} {file_diff.file_path}"
+                if file_diff.summary:
+                    label = f"{label} [dim]- {file_diff.summary}[/dim]"
+                tree.add(label)
+            remaining = len(cluster.files) - MAX_FILES_IN_PREVIEW
+            if remaining > 0:
+                tree.add(f"[dim]and {remaining} more[/dim]")
+            reason = cluster.reason or "Grouped by deterministic repository analysis."
+            self.console.print(
+                Panel.fit(
+                    tree,
+                    title=f"Commit {index}",
+                    subtitle=f"confidence: {cluster.confidence:.0%} | {reason}",
+                )
+            )
+
+        table = Table(title="Commit Summary", show_header=True)
+        table.add_column("#", style="cyan")
+        table.add_column("Type", style="magenta")
+        table.add_column("Files", justify="right", style="green")
+        table.add_column("Confidence", justify="right", style="blue")
+        table.add_column("Message", style="yellow")
+        for index, cluster in enumerate(clusters, 1):
+            commit_type = cluster.commit_type.value if cluster.commit_type else "chore"
+            table.add_row(
+                str(index),
+                commit_type,
+                str(len(cluster.files)),
+                f"{cluster.confidence:.0%}",
+                (cluster.message or cluster.summary or "chore: update files")[:72],
+            )
+        self.console.print()
+        self.console.print(table)
+        self.console.print(
+            f"[bold green]Summary:[/bold green] {len(clusters)} commit(s) covering {total_files} file(s)"
+        )
+        self.console.print()
+
+    @staticmethod
+    def _render_plain(clusters: list[CommitCluster], total_files: int) -> None:
+        print()
+        print(f"Smart Commit Preview - {len(clusters)} commit(s)")
+        for index, cluster in enumerate(clusters, 1):
+            print(f"\nCommit {index}: {cluster.message or cluster.summary or 'chore: update files'}")
+            print(f"  Confidence: {cluster.confidence:.0%}")
+            print(f"  Reason: {cluster.reason or 'Grouped by deterministic repository analysis.'}")
+            for file_diff in cluster.files[:MAX_FILES_IN_PREVIEW]:
+                suffix = f" - {file_diff.summary}" if file_diff.summary else ""
+                print(f"  {file_diff.status} {file_diff.file_path}{suffix}")
+            remaining = len(cluster.files) - MAX_FILES_IN_PREVIEW
+            if remaining > 0:
+                print(f"  and {remaining} more")
+        print(f"\nSummary: {len(clusters)} commit(s) covering {total_files} file(s)\n")
+
+

smart_commit/preview.py

@@ -0,0 +1,131 @@
+"""Interactive preview UI for commits."""
+
+from typing import List, Optional
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+from .models import CommitCluster, FileDiff
+
+
+class PreviewUI:
+    """Interactive preview interface for reviewing commits."""
+
+    def __init__(self):
+        """Initialize preview UI."""
+        self.console = Console()
+
+    def display_clusters(self, clusters: List[CommitCluster]) -> None:
+        """Display all clusters for review.
+        
+        Args:
+            clusters: List of CommitCluster objects to display.
+        """
+        for idx, cluster in enumerate(clusters, 1):
+            self.display_cluster(cluster, idx)
+
+    def display_cluster(self, cluster: CommitCluster, cluster_num: int) -> None:
+        """Display a single cluster.
+        
+        Args:
+            cluster: CommitCluster to display.
+            cluster_num: Cluster number for display.
+        """
+        title = cluster.message or cluster.summary or "Untitled"
+        
+        panel_content = f"[bold cyan]Cluster {cluster_num}[/bold cyan]\n"
+        panel_content += f"[yellow]{title}[/yellow]\n"
+        panel_content += f"Files: {len(cluster.files)}\n"
+        
+        # File table
+        table = Table(show_header=False)
+        table.add_column("File", style="cyan")
+        table.add_column("Status", style="magenta")
+        
+        for file_diff in cluster.files[:5]:
+            table.add_row(file_diff.file_path, file_diff.status)
+        
+        if len(cluster.files) > 5:
+            table.add_row(f"... and {len(cluster.files) - 5} more", "")
+        
+        self.console.print(Panel(panel_content + str(table)))
+
+    def get_cluster_actions(self, cluster_num: int) -> Optional[str]:
+        """Get user actions for a cluster.
+        
+        Args:
+            cluster_num: Cluster number.
+        
+        Returns:
+            User action ('accept', 'edit', 'split', 'merge', 'skip', etc.)
+        """
+        prompt = (
+            f"\n[cyan]Cluster {cluster_num}[/cyan]\n"
+            "[green][a][/green] Accept  "
+            "[green][e][/green] Edit  "
+            "[green][s][/green] Split  "
+            "[green][m][/green] Merge  "
+            "[green][d][/green] Discard  "
+            "[green][q][/green] Quit\n"
+        )
+        
+        action = self.console.input(prompt).lower().strip()
+        
+        if action in ['a', 'e', 's', 'm', 'd', 'q']:
+            return action
+        
+        return None
+
+    def edit_cluster(self, cluster: CommitCluster) -> CommitCluster:
+        """Allow user to edit a cluster.
+        
+        Args:
+            cluster: CommitCluster to edit.
+        
+        Returns:
+            Modified CommitCluster.
+        """
+        self.console.print("[yellow]Cluster editing not yet implemented[/yellow]")
+        return cluster
+
+    def select_files_for_split(self, cluster: CommitCluster) -> tuple:
+        """Allow user to select files for cluster split.
+        
+        Args:
+            cluster: CommitCluster to split.
+        
+        Returns:
+            Tuple of (files_for_cluster1, files_for_cluster2)
+        """
+        self.console.print("[yellow]File selection for split not yet implemented[/yellow]")
+        return (cluster.files[:len(cluster.files)//2], cluster.files[len(cluster.files)//2:])
+
+    def display_summary(self, clusters: List[CommitCluster], total_changes: int) -> None:
+        """Display summary of all commits.
+        
+        Args:
+            clusters: List of clusters to summarize.
+            total_changes: Total number of changed files.
+        """
+        table = Table(title="Commit Summary")
+        table.add_column("Commit", style="cyan")
+        table.add_column("Type", style="magenta")
+        table.add_column("Files", style="green")
+        table.add_column("Message", style="yellow")
+        
+        for idx, cluster in enumerate(clusters, 1):
+            message = cluster.message or cluster.summary or "Untitled"
+            commit_type = cluster.commit_type.value if cluster.commit_type else "chore"
+            table.add_row(
+                f"#{idx}",
+                commit_type,
+                str(len(cluster.files)),
+                message[:40]
+            )
+        
+        self.console.print(table)
+        self.console.print(
+            f"\n[bold]Summary:[/bold] "
+            f"{len(clusters)} commit(s) covering {total_changes} changed file(s)"
+        )
+

smart_commit/summarizer.py

@@ -0,0 +1,93 @@
+"""Summarizer for converting diffs into concise summaries."""
+
+from typing import List, Optional
+from .models import FileDiff
+from .diff_parser import DiffParser
+
+
+class Summarizer:
+    """Converts raw diffs into concise, semantic summaries."""
+
+    def __init__(self):
+        """Initialize the summarizer."""
+        self.diff_parser = DiffParser()
+
+    def summarize_file_diff(self, file_diff: FileDiff) -> str:
+        """Generate a summary for a single file's diff.
+        
+        Args:
+            file_diff: FileDiff object.
+        
+        Returns:
+            Summary string.
+        """
+        if file_diff.summary:
+            return file_diff.summary
+        
+        # Use DiffParser to extract summary
+        summary = self.diff_parser.extract_summary(
+            file_diff.raw_diff,
+            file_diff.file_path
+        )
+        
+        return summary
+
+    def summarize_cluster(self, file_diffs: List[FileDiff]) -> str:
+        """Generate a summary for a cluster of files.
+        
+        Args:
+            file_diffs: List of FileDiff objects.
+        
+        Returns:
+            Cluster summary.
+        """
+        if not file_diffs:
+            return "No changes"
+        
+        # Get individual summaries
+        summaries = []
+        for diff in file_diffs:
+            summary = self.summarize_file_diff(diff)
+            summaries.append(summary)
+        
+        # Combine summaries
+        unique_summaries = list(set(summaries))
+        
+        if len(unique_summaries) == 1:
+            return unique_summaries[0]
+        
+        # Take top 3 summaries
+        return "; ".join(unique_summaries[:3])
+
+    def extract_keywords(self, file_diff: FileDiff) -> List[str]:
+        """Extract keywords from a file diff.
+        
+        Args:
+            file_diff: FileDiff object.
+        
+        Returns:
+            List of keywords.
+        """
+        keywords = []
+        
+        # Extract from file path
+        path_parts = file_diff.file_path.lower().split('/')
+        for part in path_parts:
+            if part and part not in ['src', 'lib', 'utils', 'test']:
+                keywords.append(part)
+        
+        # Extract from diff content
+        changes = self.diff_parser.parse_diff(
+            file_diff.raw_diff,
+            file_diff.file_path
+        )
+        
+        for change in changes:
+            # Extract nouns and verbs
+            words = change.split()
+            for word in words:
+                if len(word) > 3 and word.lower() not in ['added', 'removed', 'modified']:
+                    keywords.append(word.lower())
+        
+        return list(set(keywords))
+

smart_commit/utils.py

@@ -0,0 +1,83 @@
+"""Utility functions for Smart Commit."""
+
+import os
+import sys
+import json
+from pathlib import Path
+from typing import Optional, Any
+from datetime import datetime
+import uuid
+
+
+def get_project_root() -> Path:
+    """Get the Smart Commit project root directory."""
+    return Path(__file__).parent.parent
+
+
+def get_home_config_dir() -> Path:
+    """Get the user's Smart Commit config directory."""
+    config_dir = Path.home() / ".smart_commit"
+    config_dir.mkdir(parents=True, exist_ok=True)
+    return config_dir
+
+
+def get_session_history_file(repo_path: Path) -> Path:
+    """Get the session history file for a repository."""
+    config_dir = get_home_config_dir()
+    session_dir = config_dir / "sessions"
+    session_dir.mkdir(parents=True, exist_ok=True)
+    
+    # Create a hash-based filename from the repository path
+    import hashlib
+    repo_hash = hashlib.md5(str(repo_path.absolute()).encode()).hexdigest()[:8]
+    
+    return session_dir / f"sessions_{repo_hash}.json"
+
+
+def generate_session_id() -> str:
+    """Generate a unique session ID."""
+    return str(uuid.uuid4())
+
+
+def get_timestamp() -> str:
+    """Get current timestamp in ISO format."""
+    return datetime.now().isoformat()
+
+
+def load_json_file(file_path: Path) -> Any:
+    """Load JSON from file, return empty dict if not found."""
+    if not file_path.exists():
+        return {}
+    
+    try:
+        with open(file_path) as f:
+            return json.load(f)
+    except (json.JSONDecodeError, IOError):
+        return {}
+
+
+def save_json_file(file_path: Path, data: Any) -> None:
+    """Save data to JSON file."""
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    with open(file_path, 'w') as f:
+        json.dump(data, f, indent=2)
+
+
+def format_bytes(num_bytes: int) -> str:
+    """Format bytes to human-readable string."""
+    for unit in ['B', 'KB', 'MB', 'GB']:
+        if num_bytes < 1024.0:
+            return f"{num_bytes:.1f}{unit}"
+        num_bytes /= 1024.0
+    
+    return f"{num_bytes:.1f}TB"
+
+
+def truncate_string(text: str, max_length: int = 100) -> str:
+    """Truncate string to max length with ellipsis."""
+    if len(text) <= max_length:
+        return text
+    
+    return text[:max_length - 3] + "..."
+