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

smart_commit/git/scanner.py

@@ -0,0 +1,182 @@
+"""Repository scanning using the Git CLI."""
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+import subprocess
+
+from ..constants import FileStatus
+from ..exceptions import InvalidRepositoryError, NoChangesError
+from ..models import FileDiff
+
+
+@dataclass
+class RepositorySnapshot:
+    """Snapshot of repository state."""
+
+    repo_path: Path
+    branch: str
+    modified_files: list[FileDiff]
+    staged_files: list[FileDiff]
+    untracked_files: list[FileDiff]
+    total_files_changed: int
+    total_additions: int
+    total_deletions: int
+
+    @property
+    def all_files(self) -> list[FileDiff]:
+        """Return changed files without duplicate paths."""
+        files_by_path: dict[str, FileDiff] = {}
+        for file_diff in [*self.staged_files, *self.modified_files, *self.untracked_files]:
+            existing = files_by_path.get(file_diff.file_path)
+            if existing:
+                existing.raw_diff = "\n".join(
+                    part for part in [existing.raw_diff, file_diff.raw_diff] if part
+                )
+                existing.additions += file_diff.additions
+                existing.deletions += file_diff.deletions
+            else:
+                files_by_path[file_diff.file_path] = file_diff
+        return list(files_by_path.values())
+
+
+class RepositoryScanner:
+    """Scans a Git repository for staged, unstaged, and untracked changes."""
+
+    def __init__(self, repo_path: Optional[Path] = None) -> None:
+        self.repo_path = self._resolve_repo_path(repo_path or Path.cwd())
+
+    def scan(self) -> RepositorySnapshot:
+        """Scan repository and return a snapshot."""
+        staged_files = self._changed_files(staged=True)
+        modified_files = self._changed_files(staged=False)
+        untracked_files = self._untracked_files()
+
+        snapshot = RepositorySnapshot(
+            repo_path=self.repo_path,
+            branch=self._branch_name(),
+            modified_files=modified_files,
+            staged_files=staged_files,
+            untracked_files=untracked_files,
+            total_files_changed=0,
+            total_additions=0,
+            total_deletions=0,
+        )
+        all_files = snapshot.all_files
+        if not all_files:
+            raise NoChangesError("No changes found in repository")
+
+        snapshot.total_files_changed = len(all_files)
+        snapshot.total_additions = sum(file_diff.additions for file_diff in all_files)
+        snapshot.total_deletions = sum(file_diff.deletions for file_diff in all_files)
+        return snapshot
+
+    def _changed_files(self, staged: bool) -> list[FileDiff]:
+        names_args = ["diff", "--cached", "--name-status", "--find-renames"] if staged else ["diff", "--name-status", "--find-renames"]
+        output = self._git(*names_args)
+        file_diffs = []
+        for line in output.splitlines():
+            if not line.strip():
+                continue
+            parts = line.split("\t")
+            status_code = parts[0][0]
+            
+            if status_code in ('R', 'C') and len(parts) >= 3:
+                old_path = parts[1]
+                path = parts[2]
+                is_renamed = True
+            else:
+                old_path = None
+                path = parts[-1]
+                is_renamed = False
+                
+            diff_args = ["diff", "--cached", "--find-renames", "--", path] if staged else ["diff", "--find-renames", "--", path]
+            raw_diff = self._git(*diff_args)
+            additions, deletions = self._count_changed_lines(raw_diff)
+            file_diffs.append(
+                FileDiff(
+                    file_path=path,
+                    status=self._normalize_status(status_code),
+                    additions=additions,
+                    deletions=deletions,
+                    raw_diff=raw_diff,
+                    old_file_path=old_path,
+                    is_renamed=is_renamed,
+                )
+            )
+        return file_diffs
+
+    def _untracked_files(self) -> list[FileDiff]:
+        output = self._git("ls-files", "--others", "--exclude-standard")
+        file_diffs = []
+        for path in output.splitlines():
+            absolute_path = self.repo_path / path
+            try:
+                content = absolute_path.read_text(encoding="utf-8", errors="ignore")
+            except OSError:
+                content = ""
+            raw_diff = "\n".join(f"+{line}" for line in content.splitlines())
+            file_diffs.append(
+                FileDiff(
+                    file_path=path,
+                    status=FileStatus.UNTRACKED.value,
+                    additions=len(content.splitlines()) if content else 0,
+                    deletions=0,
+                    raw_diff=raw_diff,
+                )
+            )
+        return file_diffs
+
+    def _branch_name(self) -> str:
+        branch = self._git("branch", "--show-current").strip()
+        if branch:
+            return branch
+        return self._git("rev-parse", "--short", "HEAD").strip()
+
+    def _git(self, *args: str) -> str:
+        result = subprocess.run(
+            ["git", *args],
+            cwd=self.repo_path,
+            text=True,
+            capture_output=True,
+            check=False,
+        )
+        if result.returncode != 0:
+            raise InvalidRepositoryError(result.stderr.strip() or "Git command failed")
+        return result.stdout
+
+    @staticmethod
+    def _resolve_repo_path(path: Path) -> Path:
+        result = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            cwd=path,
+            text=True,
+            capture_output=True,
+            check=False,
+        )
+        if result.returncode != 0:
+            raise InvalidRepositoryError(f"Not a git repository: {path.resolve()}")
+        return Path(result.stdout.strip()).resolve()
+
+    @staticmethod
+    def _count_changed_lines(diff_text: str) -> tuple[int, int]:
+        additions = 0
+        deletions = 0
+        for line in diff_text.splitlines():
+            if line.startswith(("+++", "---")):
+                continue
+            if line.startswith("+"):
+                additions += 1
+            elif line.startswith("-"):
+                deletions += 1
+        return additions, deletions
+
+    @staticmethod
+    def _normalize_status(status: str) -> str:
+        return {
+            "A": FileStatus.ADDED.value,
+            "M": FileStatus.MODIFIED.value,
+            "D": FileStatus.DELETED.value,
+            "R": FileStatus.RENAMED.value,
+            "C": FileStatus.COPIED.value,
+        }.get(status, FileStatus.MODIFIED.value)

smart_commit/git/service.py

@@ -0,0 +1,129 @@
+"""Git service backed by the Git CLI."""
+
+from pathlib import Path
+from typing import Optional
+import subprocess
+
+from ..logger import get_logger
+from ..models import SessionInfo
+from ..utils import (
+    generate_session_id,
+    get_session_history_file,
+    get_timestamp,
+    load_json_file,
+    save_json_file,
+)
+from .scanner import RepositoryScanner
+
+logger = get_logger("git.service")
+
+
+class GitService:
+    """Git operations used by Smart Commit execution."""
+
+    def __init__(self, repo_path: Optional[Path] = None) -> None:
+        self.repo_path = RepositoryScanner(repo_path).repo_path
+
+    def stage_files(self, file_paths: list[str]) -> None:
+        """Stage specific files."""
+        if file_paths:
+            self._git("add", "--", *file_paths)
+            logger.debug("Staged %s file(s)", len(file_paths))
+
+    def commit(self, message: str) -> str:
+        """Create a commit and return its hash."""
+        self._git("commit", "-m", message)
+        commit_hash = self._git("rev-parse", "HEAD").strip()
+        logger.info("Created commit: %s", commit_hash[:7])
+        return commit_hash
+
+    def current_branch(self) -> str:
+        """Return current branch or detached HEAD short hash."""
+        branch = self._git("branch", "--show-current").strip()
+        return branch or self._git("rev-parse", "--short", "HEAD").strip()
+
+    def get_commit_log(self, count: int = 10) -> list[dict]:
+        """Get recent commits."""
+        output = self._git(
+            "log",
+            f"--max-count={count}",
+            "--pretty=format:%h%x09%s%x09%an%x09%aI",
+        )
+        commits = []
+        for line in output.splitlines():
+            commit_hash, message, author, date = line.split("\t", 3)
+            commits.append(
+                {"hash": commit_hash, "message": message, "author": author, "date": date}
+            )
+        return commits
+
+    def reset_soft(self, num_commits: int = 1) -> None:
+        """Soft reset N commits."""
+        self._git("reset", "--soft", f"HEAD~{num_commits}")
+        logger.info("Soft reset HEAD~%s", num_commits)
+
+    def save_session(self, session: SessionInfo) -> None:
+        """Save session for undo support."""
+        session_file = get_session_history_file(self.repo_path)
+        sessions_data = load_json_file(session_file)
+        sessions = sessions_data.setdefault("sessions", [])
+        sessions.append(
+            {
+                "id": session.session_id or generate_session_id(),
+                "commit_hashes": session.commit_hashes,
+                "timestamp": session.timestamp or get_timestamp(),
+                "branch": session.branch,
+                "repository_path": session.repository_path,
+            }
+        )
+        sessions_data["sessions"] = sessions[-50:]
+        save_json_file(session_file, sessions_data)
+
+    def get_last_session(self) -> Optional[SessionInfo]:
+        """Return the latest Smart Commit session for this repository."""
+        session_file = get_session_history_file(self.repo_path)
+        sessions_data = load_json_file(session_file)
+        sessions = sessions_data.get("sessions") or []
+        if not sessions:
+            return None
+        data = sessions[-1]
+        return SessionInfo(
+            session_id=data["id"],
+            commit_hashes=data["commit_hashes"],
+            timestamp=data["timestamp"],
+            branch=data["branch"],
+            repository_path=data["repository_path"],
+        )
+
+    def undo_last_session(self) -> bool:
+        """Undo the last Smart Commit session."""
+        session = self.get_last_session()
+        if not session or not session.commit_hashes:
+            return False
+
+        try:
+            self.reset_soft(len(session.commit_hashes))
+            self._remove_last_session()
+            return True
+        except RuntimeError as exc:
+            logger.error("Failed to undo: %s", exc)
+            return False
+
+    def _remove_last_session(self) -> None:
+        session_file = get_session_history_file(self.repo_path)
+        sessions_data = load_json_file(session_file)
+        sessions = sessions_data.get("sessions") or []
+        sessions_data["sessions"] = sessions[:-1]
+        save_json_file(session_file, sessions_data)
+
+    def _git(self, *args: str) -> str:
+        result = subprocess.run(
+            ["git", *args],
+            cwd=self.repo_path,
+            text=True,
+            capture_output=True,
+            check=False,
+        )
+        if result.returncode != 0:
+            raise RuntimeError(result.stderr.strip() or "Git command failed")
+        return result.stdout

smart_commit/git_service.py

@@ -0,0 +1,302 @@
+"""Git service for repository operations."""
+
+from pathlib import Path
+from typing import Optional, List, Set
+import git
+from git.exc import InvalidGitRepositoryError, GitCommandError
+
+from .models import FileDiff, SessionInfo
+from .utils import generate_session_id, get_timestamp, get_session_history_file, load_json_file, save_json_file
+
+
+class GitService:
+    """Handles all Git operations."""
+
+    def __init__(self, repo_path: Optional[Path] = None):
+        """Initialize GitService.
+        
+        Args:
+            repo_path: Path to git repository. If None, uses current directory.
+        
+        Raises:
+            InvalidGitRepositoryError: If no valid git repository found.
+        """
+        if repo_path is None:
+            repo_path = Path.cwd()
+        
+        self.repo_path = Path(repo_path).resolve()
+        
+        try:
+            self.repo = git.Repo(self.repo_path)
+        except InvalidGitRepositoryError:
+            raise InvalidGitRepositoryError(
+                f"No git repository found at {self.repo_path}"
+            )
+
+    def discover_repository(self) -> Path:
+        """Discover and return the repository root path.
+        
+        Returns:
+            Path to repository root.
+        """
+        return Path(self.repo.working_dir)
+
+    def get_changed_files(self) -> List[FileDiff]:
+        """Get all changed files in the working directory.
+        
+        Returns:
+            List of FileDiff objects for changed files.
+        """
+        changed_files = []
+        
+        # Get all modified and untracked files
+        for item in self.repo.index.diff(None):
+            file_diff = self._diff_index_to_filediff(item)
+            changed_files.append(file_diff)
+        
+        # Add untracked files
+        for untracked in self.repo.untracked_files:
+            changed_files.append(
+                FileDiff(
+                    file_path=untracked,
+                    status="A",  # Treat as added
+                    additions=0,
+                    deletions=0,
+                    raw_diff="",
+                    summary="Untracked file"
+                )
+            )
+        
+        return changed_files
+
+    def get_staged_files(self) -> List[FileDiff]:
+        """Get all staged files.
+        
+        Returns:
+            List of FileDiff objects for staged files.
+        """
+        staged_files = []
+        
+        # Get staged changes
+        for item in self.repo.index.diff("HEAD"):
+            file_diff = self._diff_index_to_filediff(item)
+            staged_files.append(file_diff)
+        
+        return staged_files
+
+    def get_diff(self, file_path: str) -> str:
+        """Get the full diff for a specific file.
+        
+        Args:
+            file_path: Path to the file.
+        
+        Returns:
+            Raw diff content.
+        """
+        try:
+            diff = self.repo.git.diff(file_path)
+            return diff
+        except GitCommandError as e:
+            return ""
+
+    def stage_files(self, file_paths: List[str]) -> None:
+        """Stage specific files for commit.
+        
+        Args:
+            file_paths: List of file paths to stage.
+        
+        Raises:
+            GitCommandError: If staging fails.
+        """
+        if not file_paths:
+            return
+        
+        self.repo.index.add(file_paths)
+
+    def unstage_files(self, file_paths: List[str]) -> None:
+        """Unstage specific files.
+        
+        Args:
+            file_paths: List of file paths to unstage.
+        """
+        if not file_paths:
+            return
+        
+        self.repo.index.reset(paths=file_paths)
+
+    def commit(self, message: str, author_name: Optional[str] = None, 
+               author_email: Optional[str] = None) -> str:
+        """Create a commit with staged changes.
+        
+        Args:
+            message: Commit message.
+            author_name: Author name (uses git config if None).
+            author_email: Author email (uses git config if None).
+        
+        Returns:
+            Commit hash.
+        
+        Raises:
+            GitCommandError: If commit fails.
+        """
+        # Get author from git config if not provided
+        if author_name is None:
+            author_name = self.repo.config_reader().get_value("user", "name")
+        if author_email is None:
+            author_email = self.repo.config_reader().get_value("user", "email")
+        
+        from git import Actor
+        
+        actor = Actor(author_name, author_email) if author_name and author_email else None
+        
+        # Create commit
+        if actor:
+            commit = self.repo.index.commit(message, author=actor)
+        else:
+            commit = self.repo.index.commit(message)
+        
+        return commit.hexsha
+
+    def current_branch(self) -> str:
+        """Get current branch name.
+        
+        Returns:
+            Current branch name.
+        """
+        return self.repo.active_branch.name
+
+    def get_commit_log(self, count: int = 10) -> List[dict]:
+        """Get recent commit log.
+        
+        Args:
+            count: Number of commits to retrieve.
+        
+        Returns:
+            List of commit info dictionaries.
+        """
+        commits = []
+        
+        for commit in self.repo.iter_commits(max_count=count):
+            commits.append({
+                "hash": commit.hexsha[:7],
+                "message": commit.message.split('\n')[0],
+                "author": commit.author.name,
+                "date": commit.committed_datetime.isoformat()
+            })
+        
+        return commits
+
+    def reset_soft(self, num_commits: int = 1) -> None:
+        """Reset HEAD to N commits back (soft reset, keeps changes staged).
+        
+        Args:
+            num_commits: Number of commits to reset.
+        
+        Raises:
+            GitCommandError: If reset fails.
+        """
+        self.repo.git.reset("--soft", f"HEAD~{num_commits}")
+
+    def save_session(self, session: SessionInfo) -> None:
+        """Save session info for undo support.
+        
+        Args:
+            session: SessionInfo object to save.
+        """
+        session_file = get_session_history_file(self.repo_path)
+        
+        # Load existing sessions
+        sessions_data = load_json_file(session_file)
+        if "sessions" not in sessions_data:
+            sessions_data["sessions"] = []
+        
+        # Add new session
+        sessions_data["sessions"].append({
+            "id": session.session_id,
+            "commit_hashes": session.commit_hashes,
+            "timestamp": session.timestamp,
+            "branch": session.branch,
+            "repository_path": session.repository_path
+        })
+        
+        # Keep only last 50 sessions
+        sessions_data["sessions"] = sessions_data["sessions"][-50:]
+        
+        save_json_file(session_file, sessions_data)
+
+    def get_last_session(self) -> Optional[SessionInfo]:
+        """Get the last Smart Commit session.
+        
+        Returns:
+            SessionInfo object or None if no sessions found.
+        """
+        session_file = get_session_history_file(self.repo_path)
+        sessions_data = load_json_file(session_file)
+        
+        if not sessions_data.get("sessions"):
+            return None
+        
+        last_session_data = sessions_data["sessions"][-1]
+        
+        return SessionInfo(
+            session_id=last_session_data["id"],
+            commit_hashes=last_session_data["commit_hashes"],
+            timestamp=last_session_data["timestamp"],
+            branch=last_session_data["branch"],
+            repository_path=last_session_data["repository_path"]
+        )
+
+    def undo_last_session(self) -> bool:
+        """Undo the last Smart Commit session.
+        
+        Returns:
+            True if undo was successful, False otherwise.
+        """
+        session = self.get_last_session()
+        
+        if not session or not session.commit_hashes:
+            return False
+        
+        num_commits = len(session.commit_hashes)
+        
+        try:
+            self.reset_soft(num_commits)
+            return True
+        except GitCommandError:
+            return False
+
+    @staticmethod
+    def _diff_index_to_filediff(item) -> FileDiff:
+        """Convert git diff item to FileDiff object.
+        
+        Args:
+            item: Git diff item.
+        
+        Returns:
+            FileDiff object.
+        """
+        # Determine file status
+        if item.deleted_file:
+            status = "D"
+        elif item.new_file:
+            status = "A"
+        elif item.renamed_file:
+            status = "R"
+        else:
+            status = "M"
+        
+        file_path = item.a_path or item.b_path
+        
+        # Count lines added/deleted
+        diff_text = item.diff.decode('utf-8', errors='ignore') if isinstance(item.diff, bytes) else item.diff
+        additions = diff_text.count('\n+') 
+        deletions = diff_text.count('\n-')
+        
+        return FileDiff(
+            file_path=file_path,
+            status=status,
+            additions=additions,
+            deletions=deletions,
+            raw_diff=diff_text
+        )
+