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

smart_commit/cli.py

@@ -0,0 +1,391 @@
+"""Smart Commit v2 command line interface."""
+
+from pathlib import Path
+from typing import Optional
+import argparse
+import sys
+
+from . import __version__
+from .analysis import DiffParser, Summarizer
+from .analysis.symbol_extractor import SymbolExtractor
+from .clustering import HeuristicClustering, SemanticClustering
+from .commit_messages import CommitMessageGenerator
+from .config import Config
+from .constants import CONFIG_FILE
+from .exceptions import InvalidRepositoryError, NoChangesError, SmartCommitException
+from .execution import Committer
+from .git import GitService, RepositoryScanner
+from .logger import get_logger, setup_logging
+from .models import CommitCluster
+from .plugins import PluginRegistry
+from .preview import PreviewRenderer, InteractiveEditor
+
+try:
+    from rich.progress import Progress, SpinnerColumn, TextColumn
+except ImportError:
+    Progress = None
+    SpinnerColumn = None
+    TextColumn = None
+
+logger = get_logger("cli")
+
+
+def build_clusters(
+    repo_path: Path,
+    *,
+    no_ai: bool = False,
+    offline: bool = False,
+    provider: Optional[str] = None,
+    model: Optional[str] = None,
+    max_files: Optional[int] = None,
+) -> tuple[list[CommitCluster], object]:
+    """Run the PRD pipeline up to commit proposals."""
+    config = Config.load()
+    if provider:
+        config.provider = provider
+    if model:
+        config.model = model
+    if max_files:
+        config.max_files_per_commit = max_files
+
+    snapshot = RepositoryScanner(repo_path).scan()
+    parser = DiffParser()
+    extractor = SymbolExtractor()
+    summarizer = Summarizer()
+
+    for file_diff in snapshot.all_files:
+        parser.enrich_file_diff(file_diff)
+        file_diff.extracted_symbols = extractor.extract_symbols(file_diff)
+        file_diff.summary = summarizer.summarize_file_diff(file_diff)
+
+    if offline or no_ai or not config.use_local_embeddings:
+        clusters = HeuristicClustering().cluster_files(snapshot.all_files, config.max_files_per_commit)
+    else:
+        clusters = SemanticClustering(config.similarity_threshold).cluster_files(snapshot.all_files, repo_path=repo_path)
+
+    for cluster in clusters:
+        cluster.summary = summarizer.summarize_cluster(cluster.files)
+        if not cluster.reason:
+            cluster.reason = "Grouped by deterministic path, summary, symbol, and import analysis."
+
+    if not offline and not no_ai:
+        clusters = review_with_ai(clusters, config)
+
+    message_generator = CommitMessageGenerator(config)
+    for cluster in clusters:
+        cluster.commit_type = message_generator._infer_commit_type(cluster)
+        cluster.message = message_generator.generate_title(cluster)
+
+    return clusters, snapshot
+
+
+def review_with_ai(clusters: list[CommitCluster], config: Config) -> list[CommitCluster]:
+    """Let the LLM review clusters without depending on it for correctness."""
+    if not config.api_key:
+        return clusters
+
+    try:
+        from .ai import ClusterReviewer, LLMClient
+
+        reviewer = ClusterReviewer(LLMClient(config))
+        for cluster in clusters:
+            review = reviewer.review_cluster(cluster)
+            if review.get("status") == "error":
+                continue
+            cluster.confidence = float(review.get("confidence", cluster.confidence))
+            if review.get("reason"):
+                cluster.reason = review["reason"]
+    except Exception as exc:
+        logger.warning("AI review skipped: %s", exc)
+    return clusters
+
+
+def print_scan_summary(snapshot: object) -> None:
+    """Print repository scan summary."""
+    print(f"  Found {snapshot.total_files_changed} changed file(s)")
+    print(f"  +{snapshot.total_additions} additions, -{snapshot.total_deletions} deletions")
+    print(f"  Branch: {snapshot.branch}")
+
+
+def command_run(args: argparse.Namespace) -> int:
+    """Analyze changes, preview logical commits, and commit after approval."""
+    repo_path = Path(args.path or Path.cwd())
+    try:
+        print(f"Smart Commit v{__version__}")
+        print("Organize Git history before you commit\n")
+        if Progress:
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                transient=True,
+            ) as progress:
+                progress.add_task(description="Scanning repository and analyzing files...", total=None)
+                clusters, snapshot = build_clusters(
+                    repo_path,
+                    no_ai=args.no_ai,
+                    offline=args.offline,
+                    provider=args.provider,
+                    model=args.model,
+                    max_files=args.max_files,
+                )
+        else:
+            print("Step 1: Scanning repository...")
+            clusters, snapshot = build_clusters(
+                repo_path,
+                no_ai=args.no_ai,
+                offline=args.offline,
+                provider=args.provider,
+                model=args.model,
+                max_files=args.max_files,
+            )
+            
+        print("Step 1: Analysis Complete")
+        print_scan_summary(snapshot)
+
+        print("\nStep 2: Proposed commit plan")
+        renderer = PreviewRenderer()
+
+        if args.dry_run:
+            renderer.render_clusters(clusters, snapshot.total_files_changed)
+            print("Dry run complete. No commits were created.")
+            return 0
+
+        if not args.yes:
+            editor = InteractiveEditor(clusters, snapshot.total_files_changed, renderer)
+            response = editor.edit()
+            if response in {"n", "d"}:
+                print("Cancelled. No commits were created.")
+                return 0
+        else:
+            renderer.render_clusters(clusters, snapshot.total_files_changed)
+
+        print("\nStep 3: Creating commits")
+        commit_hashes = Committer(GitService(repo_path)).commit_clusters(clusters)
+        print(f"Success: created {len(commit_hashes)} commit(s)")
+        for index, commit_hash in enumerate(commit_hashes, 1):
+            print(f"  {index}. {commit_hash[:7]}")
+        return 0
+    except NoChangesError:
+        print("No changes found.")
+        return 0
+    except (InvalidRepositoryError, SmartCommitException, RuntimeError) as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        return 1
+    except Exception as exc:
+        logger.exception("Unexpected failure")
+        print(f"Unexpected error: {exc}", file=sys.stderr)
+        return 1
+
+
+def command_preview(args: argparse.Namespace) -> int:
+    """Preview without committing."""
+    args.dry_run = True
+    args.yes = False
+    return command_run(args)
+
+
+def command_undo(args: argparse.Namespace) -> int:
+    """Undo the last Smart Commit session."""
+    git_service = GitService(Path(args.path or Path.cwd()))
+    session = git_service.get_last_session()
+    if not session:
+        print("No previous Smart Commit session found.")
+        return 0
+
+    print(f"Session: {session.session_id}")
+    print(f"Branch: {session.branch}")
+    print(f"Commits: {len(session.commit_hashes)}")
+    if args.yes or input("Soft reset these commits? [y/N] ").lower().strip() == "y":
+        if git_service.undo_last_session():
+            print("Session undone. Changes are staged for review.")
+            return 0
+        print("Failed to undo the last session.", file=sys.stderr)
+        return 1
+    print("Cancelled.")
+    return 0
+
+
+def command_config(args: argparse.Namespace) -> int:
+    """Show or update configuration."""
+    config = Config.load()
+    changed = False
+    if args.provider:
+        config.provider = args.provider
+        changed = True
+    if args.model:
+        config.model = args.model
+        changed = True
+    if args.api_key:
+        config.api_key = args.api_key
+        changed = True
+    if changed:
+        config.save_to_file(CONFIG_FILE)
+        print(f"Configuration saved to {CONFIG_FILE}")
+        return 0
+    if args.show:
+        print("Smart Commit Configuration")
+        print(f"  Provider: {config.provider}")
+        print(f"  Model: {config.model}")
+        print(f"  Embedding model: {config.embedding_model}")
+        print(f"  Max files per commit: {config.max_files_per_commit}")
+        print(f"  Interactive: {config.interactive}")
+        print(f"  Auto push: {config.auto_push}")
+        return 0
+    print("Use --show or provide --provider, --model, or --api-key.")
+    return 0
+
+
+def command_doctor(args: argparse.Namespace) -> int:
+    """Run diagnostic checks."""
+    checks = []
+    try:
+        scanner = RepositoryScanner(Path(args.path or Path.cwd()))
+        checks.append(("Git repository", "ok", str(scanner.repo_path)))
+    except Exception as exc:
+        checks.append(("Git repository", "fail", str(exc)))
+
+    for name, module in [
+        ("Typer", "typer"),
+        ("Rich", "rich"),
+        ("GitPython", "git"),
+        ("Pydantic", "pydantic"),
+        ("YAML", "yaml"),
+    ]:
+        try:
+            __import__(module)
+            checks.append((name, "ok", "installed"))
+        except ImportError:
+            checks.append((name, "optional", "not installed"))
+
+    config = Config.load()
+    checks.append(("LLM API key", "ok" if config.api_key else "optional", config.provider))
+    checks.append(("Auto push", "ok", "disabled" if not config.auto_push else "enabled"))
+
+    print("Smart Commit Doctor")
+    for name, status, details in checks:
+        print(f"  {name:16} {status:8} {details}")
+    return 0
+
+
+def command_explain(args: argparse.Namespace) -> int:
+    """Explain grouping decisions."""
+    clusters, snapshot = build_clusters(Path(args.path or Path.cwd()), offline=args.offline)
+    print_scan_summary(snapshot)
+    for index, cluster in enumerate(clusters, 1):
+        print(f"\nCommit {index}: {cluster.message}")
+        print(f"Reason: {cluster.reason}")
+        print(f"Confidence: {cluster.confidence:.0%}")
+        for file_diff in cluster.files:
+            print(f"  {file_diff.status} {file_diff.file_path}")
+    return 0
+
+
+def command_plugins(_: argparse.Namespace) -> int:
+    """List plugins."""
+    registry = PluginRegistry()
+    print("Smart Commit Plugins")
+    for name in registry.list_plugins():
+        plugin = registry.get_plugin(name)
+        print(f"  {plugin.name} {plugin.version}: {plugin.description}")
+    return 0
+
+
+def command_benchmark(args: argparse.Namespace) -> int:
+    """Run performance benchmark."""
+    from .benchmark import BenchmarkHarness
+    harness = BenchmarkHarness(Path(args.path or Path.cwd()))
+    harness.run()
+    return 0
+
+
+def command_init(args: argparse.Namespace) -> int:
+    """Initialize repository configuration."""
+    scanner = RepositoryScanner(Path(args.path or Path.cwd()))
+    if not CONFIG_FILE.exists():
+        Config().save_to_file(CONFIG_FILE)
+    print(f"Smart Commit initialized for {scanner.repo_path}")
+    print(f"Config: {CONFIG_FILE}")
+    return 0
+
+
+def command_version(_: argparse.Namespace) -> int:
+    """Show version information."""
+    print(f"smart-commit {__version__}")
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build the CLI parser."""
+    parser = argparse.ArgumentParser(prog="smart-commit")
+    parser.add_argument("--verbose", "-v", action="store_true", help="Enable verbose logging")
+    subparsers = parser.add_subparsers(dest="command")
+
+    run_parser = subparsers.add_parser("run", help="Analyze and create commits")
+    add_pipeline_options(run_parser)
+    run_parser.add_argument("--yes", action="store_true", help="Execute without prompting")
+    run_parser.add_argument("--dry-run", action="store_true", help="Preview only")
+    run_parser.set_defaults(func=command_run)
+
+    preview_parser = subparsers.add_parser("preview", help="Preview proposed commits")
+    add_pipeline_options(preview_parser)
+    preview_parser.set_defaults(func=command_preview)
+
+    undo_parser = subparsers.add_parser("undo", help="Undo the last Smart Commit session")
+    undo_parser.add_argument("--path", "-p")
+    undo_parser.add_argument("--yes", action="store_true")
+    undo_parser.set_defaults(func=command_undo)
+
+    config_parser = subparsers.add_parser("config", help="Show or update config")
+    config_parser.add_argument("--show", action="store_true")
+    config_parser.add_argument("--provider")
+    config_parser.add_argument("--model")
+    config_parser.add_argument("--api-key")
+    config_parser.set_defaults(func=command_config)
+
+    doctor_parser = subparsers.add_parser("doctor", help="Run diagnostics")
+    doctor_parser.add_argument("--path", "-p")
+    doctor_parser.set_defaults(func=command_doctor)
+
+    explain_parser = subparsers.add_parser("explain", help="Explain grouping decisions")
+    explain_parser.add_argument("--path", "-p")
+    explain_parser.add_argument("--offline", action="store_true", default=True)
+    explain_parser.set_defaults(func=command_explain)
+
+    subparsers.add_parser("plugins", help="List plugins").set_defaults(func=command_plugins)
+
+    init_parser = subparsers.add_parser("init", help="Initialize Smart Commit")
+    init_parser.add_argument("--path", "-p")
+    init_parser.set_defaults(func=command_init)
+
+    subparsers.add_parser("version", help="Show version").set_defaults(func=command_version)
+    
+    benchmark_parser = subparsers.add_parser("benchmark", help="Run performance benchmark")
+    benchmark_parser.add_argument("--path", "-p")
+    benchmark_parser.set_defaults(func=command_benchmark)
+    
+    return parser
+
+
+def add_pipeline_options(parser: argparse.ArgumentParser) -> None:
+    """Add shared pipeline flags."""
+    parser.add_argument("--path", "-p")
+    parser.add_argument("--no-ai", action="store_true", help="Disable LLM review")
+    parser.add_argument("--offline", action="store_true", help="Disable AI and embeddings")
+    parser.add_argument("--provider")
+    parser.add_argument("--model")
+    parser.add_argument("--max-files", type=int)
+
+
+def app(argv: Optional[list[str]] = None) -> int:
+    """CLI entry point used by the console script."""
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    setup_logging(verbose=getattr(args, "verbose", False))
+    if not getattr(args, "command", None):
+        parser.print_help()
+        return 0
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(app())

smart_commit/clustering/__init__.py

@@ -0,0 +1,7 @@
+"""Clustering package."""
+
+from .semantic import SemanticClustering
+from .heuristic import HeuristicClustering
+
+__all__ = ["SemanticClustering", "HeuristicClustering"]
+

smart_commit/clustering/graph_clustering.py

@@ -0,0 +1,78 @@
+"""Graph-based clustering using community detection."""
+
+import numpy as np
+from typing import List
+
+from ..models import FileDiff, CommitCluster
+from ..logger import get_logger
+
+logger = get_logger("clustering.graph_clustering")
+
+
+class GraphClustering:
+    """Clusters files using networkx community detection."""
+
+    def __init__(self):
+        self.networkx_available = False
+        try:
+            import networkx as nx
+            self.nx = nx
+            self.networkx_available = True
+        except ImportError:
+            logger.warning("networkx not installed; GraphClustering unavailable")
+
+    def is_available(self) -> bool:
+        return self.networkx_available
+
+    def cluster_files(self, similarity_matrix: np.ndarray, file_diffs: List[FileDiff]) -> List[int]:
+        """Cluster files using Louvain community detection.
+        
+        Args:
+            similarity_matrix: N x N similarity matrix.
+            file_diffs: List of FileDiffs.
+            
+        Returns:
+            List of cluster labels corresponding to file_diffs.
+        """
+        if not self.networkx_available:
+            # Fallback to single cluster
+            return [0] * len(file_diffs)
+            
+        G = self.nx.Graph()
+        n = len(file_diffs)
+        
+        # Add nodes
+        for i in range(n):
+            G.add_node(i)
+            
+        # Add edges for similarities > threshold (e.g., 0.3)
+        for i in range(n):
+            for j in range(i + 1, n):
+                sim = similarity_matrix[i][j]
+                if sim > 0.3:
+                    G.add_edge(i, j, weight=sim)
+                    
+        # If the graph is entirely disconnected or too small, fallback gracefully
+        if G.number_of_edges() == 0:
+            return list(range(n))
+            
+        try:
+            from networkx.algorithms.community import louvain_communities
+            communities = louvain_communities(G, weight='weight')
+            
+            labels = [0] * n
+            for label, comm in enumerate(communities):
+                for node in comm:
+                    labels[node] = label
+                    
+            return labels
+            
+        except Exception as e:
+            logger.warning(f"Louvain clustering failed: {e}")
+            # Fallback to greedy/connected components
+            communities = list(self.nx.connected_components(G))
+            labels = [0] * n
+            for label, comm in enumerate(communities):
+                for node in comm:
+                    labels[node] = label
+            return labels

smart_commit/clustering/heuristic.py

@@ -0,0 +1,178 @@
+from ..models import FileDiff, CommitCluster
+from ..logger import get_logger
+
+logger = get_logger("clustering.heuristic")
+
+
+class HeuristicClustering:
+    """Clustering based on static heuristics."""
+
+    def cluster_files(
+        self,
+        file_diffs: list[FileDiff],
+        max_files_per_commit: int = 8,
+    ) -> list[CommitCluster]:
+        """Cluster files using deterministic path and change-type signals."""
+        buckets: dict[str, list[FileDiff]] = {}
+
+        for file_diff in file_diffs:
+            key = self._group_key(file_diff.file_path)
+            buckets.setdefault(key, []).append(file_diff)
+
+        clusters: list[CommitCluster] = []
+        for key, files in sorted(buckets.items()):
+            for chunk_index, chunk in enumerate(self._chunks(files, max_files_per_commit)):
+                cluster = CommitCluster(
+                    id=f"heuristic_{len(clusters)}",
+                    files=chunk,
+                    confidence=self._confidence_for_key(key, chunk),
+                    reason=self._reason_for_key(key, chunk),
+                )
+                clusters.append(cluster)
+
+        logger.debug("Created %s heuristic clusters", len(clusters))
+        return clusters
+
+    @staticmethod
+    def cluster_by_directory(file_diffs: list[FileDiff]) -> list[CommitCluster]:
+        """Cluster files by directory."""
+        clusters_dict = {}
+        
+        for file_diff in file_diffs:
+            directory = HeuristicClustering._get_directory(file_diff.file_path)
+            
+            if directory not in clusters_dict:
+                clusters_dict[directory] = []
+            
+            clusters_dict[directory].append(file_diff)
+        
+        clusters = []
+        for idx, (directory, files) in enumerate(sorted(clusters_dict.items())):
+            cluster = CommitCluster(
+                id=f"heuristic_{idx}",
+                files=files
+            )
+            clusters.append(cluster)
+        
+        logger.debug(f"Created {len(clusters)} clusters by directory")
+        return clusters
+
+    @staticmethod
+    def cluster_by_file_type(file_diffs: list[FileDiff]) -> list[CommitCluster]:
+        """Cluster files by type (frontend, backend, test, docs)."""
+        clusters_dict = {}
+        
+        for file_diff in file_diffs:
+            file_type = HeuristicClustering._get_file_type(file_diff.file_path)
+            
+            if file_type not in clusters_dict:
+                clusters_dict[file_type] = []
+            
+            clusters_dict[file_type].append(file_diff)
+        
+        clusters = []
+        for idx, (file_type, files) in enumerate(sorted(clusters_dict.items())):
+            cluster = CommitCluster(
+                id=f"type_{idx}",
+                files=files
+            )
+            clusters.append(cluster)
+        
+        logger.debug(f"Created {len(clusters)} clusters by file type")
+        return clusters
+
+    @staticmethod
+    def _get_directory(file_path: str) -> str:
+        """Extract top-level directory from path."""
+        parts = file_path.replace("\\", "/").split("/")
+        return parts[0] if parts else "root"
+
+    @staticmethod
+    def _get_file_type(file_path: str) -> str:
+        """Determine file type."""
+        path_lower = file_path.lower()
+        
+        if any(x in path_lower for x in ['.jsx', '.tsx', '.vue', '.css', '.scss']):
+            return "frontend"
+        elif any(x in path_lower for x in ['.py', '.java', '.go', '.rs', '.rb', '.php']):
+            return "backend"
+        elif 'test' in path_lower or 'spec' in path_lower:
+            return "test"
+        elif any(x in path_lower for x in ['.md', '.txt', '.rst']):
+            return "docs"
+        elif any(x in path_lower for x in ['.json', '.yaml', '.yml', '.toml']):
+            return "config"
+        else:
+            return "other"
+
+    @classmethod
+    def _group_key(cls, file_path: str) -> str:
+        path = file_path.replace("\\", "/").lower()
+        parts = [part for part in path.split("/") if part]
+        filename = parts[-1] if parts else path
+        stem = filename.rsplit(".", 1)[0]
+
+        if cls._is_docs(path):
+            return "docs"
+        if cls._is_test(path):
+            domain = cls._domain_from_path(parts, stem)
+            return f"test:{domain}"
+        if cls._is_config(path):
+            return "config"
+
+        domain = cls._domain_from_path(parts, stem)
+        file_type = cls._get_file_type(path)
+        return f"{file_type}:{domain}"
+
+    @staticmethod
+    def _domain_from_path(parts: list[str], stem: str) -> str:
+        ignored = {"src", "lib", "app", "apps", "packages", "tests", "test", "spec", "smart_commit"}
+        for part in parts[:-1]:
+            if part not in ignored:
+                return part.replace("_", "-")
+
+        tokens = [token for token in stem.replace("-", "_").split("_") if token]
+        generic = {"index", "main", "utils", "helpers", "service", "services", "manager", "client"}
+        for token in tokens:
+            if token not in generic:
+                return token
+        return stem or "root"
+
+    @staticmethod
+    def _is_docs(path: str) -> bool:
+        return path.endswith((".md", ".rst", ".txt")) or "/docs/" in f"/{path}/"
+
+    @staticmethod
+    def _is_test(path: str) -> bool:
+        normalized = f"/{path}"
+        return any(part in normalized for part in ("test_", "_test.", ".test.", ".spec.", "/tests/"))
+
+    @staticmethod
+    def _is_config(path: str) -> bool:
+        config_names = {"pyproject.toml", "package.json", "tsconfig.json", ".gitignore", ".env.example"}
+        return path in config_names or path.endswith((".yaml", ".yml", ".toml", ".ini", ".cfg", ".env"))
+
+    @staticmethod
+    def _chunks(files: list[FileDiff], size: int) -> list[list[FileDiff]]:
+        return [files[index : index + size] for index in range(0, len(files), max(1, size))]
+
+    @staticmethod
+    def _confidence_for_key(key: str, files: list[FileDiff]) -> float:
+        if len(files) == 1:
+            return 0.72
+        if key.startswith(("docs", "config")):
+            return 0.86
+        return 0.78
+
+    @staticmethod
+    def _reason_for_key(key: str, files: list[FileDiff]) -> str:
+        if key == "docs":
+            return "Documentation changes are grouped separately for a readable history."
+        if key == "config":
+            return "Configuration and project metadata changes share the same operational concern."
+        if key.startswith("test:"):
+            return "Test files with the same inferred domain belong together."
+        if len(files) == 1:
+            return "Single-file change kept as its own focused commit."
+        return "Files share an inferred domain from path, filename, and file type."
+