gitux 0.1.0__py3-none-any.whl

gitux/git/exceptions.py

@@ -0,0 +1,9 @@
+"""Git-related exceptions."""
+
+
+class GitError(Exception):
+    """Raised when a git command fails."""
+
+    def __init__(self, message: str, stderr: str = "") -> None:
+        super().__init__(message)
+        self.stderr = stderr

gitux/git/parser.py

@@ -0,0 +1,83 @@
+"""Utilities for parsing git porcelain output."""
+
+from gitux.domain import FileStatus
+
+
+def parse_status(raw: str) -> list[FileStatus]:
+    """Parse output of ``git status --porcelain=v1 -z``.
+
+    Format per entry (NUL-delimited):
+        XY<SPACE>path<NUL>               # regular file (XY + space + path)
+        R<SCORE><SPACE>old<NUL>new<NUL>  # rename/copy (XY + score + space + old, then new)
+    """
+    if not raw:
+        return []
+
+    entries: list[FileStatus] = []
+    parts = raw.split("\0")
+
+    i = 0
+    while i < len(parts):
+        part = parts[i]
+        if not part:
+            i += 1
+            continue
+        if len(part) < 4:  # Minimum: XY + space + at least 1 char for path
+            i += 1
+            continue
+
+        index_status = part[0]
+        worktree_status = part[1]
+
+        path = part[3:]  # Skip XY (2 chars) + space (1 char)
+
+        if index_status in ("R", "C"):
+            if not path:  # Empty path means score wasn't separated
+                i += 1
+                continue
+            score_end = path.find(" ")
+            if score_end >= 0:
+                old_path = path[score_end + 1:]
+            else:
+                old_path = path
+            # Next part is new_path
+            i += 1
+            new_path = parts[i] if i < len(parts) else ""
+            i += 1
+            entries.append(FileStatus(
+                index_status=index_status,
+                worktree_status=worktree_status,
+                path=new_path,
+                old_path=old_path,
+            ))
+        else:
+            i += 1
+            entries.append(FileStatus(
+                index_status=index_status,
+                worktree_status=worktree_status,
+                path=path,
+                old_path=None,
+            ))
+
+    return entries
+
+
+def parse_push_output(raw: str) -> tuple[list[str], list[tuple[str, str]]]:
+    """Parse output of ``git push --porcelain``.
+
+    Returns (ok_refs, failed_refs).
+    """
+    ok_refs: list[str] = []
+    failed_refs: list[tuple[str, str]] = []
+
+    for line in raw.splitlines():
+        line = line.strip()
+        if line.startswith("ok "):
+            ok_refs.append(line[3:])
+        elif line.startswith("ng "):
+            parts = line[3:].split(" ", 1)
+            ref = parts[0] if parts else ""
+            reason = parts[1] if len(parts) > 1 else "unknown"
+            failed_refs.append((ref, reason))
+
+    return ok_refs, failed_refs

gitux/presenter/__init__.py

@@ -0,0 +1,6 @@
+"""Presenter layer — business logic orchestration."""
+
+from gitux.presenter.commit_presenter import CommitPresenter
+from gitux.presenter.repo_presenter import RepoPresenter
+
+__all__ = ["CommitPresenter", "RepoPresenter"]

gitux/presenter/commit_presenter.py

@@ -0,0 +1,107 @@
+"""Presenter for working-tree operations: status, staging, commit, push."""
+
+from gitux.domain import CommitResult, FileStatus, PushResult
+from gitux.git import (
+    GitError,
+    commit as git_commit,
+    get_file_diff,
+    get_operation_state,
+    get_remote_status,
+    get_staged_diff,
+    get_staged_file_diff,
+    get_status,
+    get_untracked_file_diff,
+    is_detached_head,
+    push as git_push,
+    stage as git_stage,
+    unstage as git_unstage,
+)
+
+
+class CommitPresenter:
+    """Business logic for viewing status, staging, committing, and pushing."""
+
+    def __init__(self) -> None:
+        self._status: list[FileStatus] = []
+
+    def load_status(self) -> list[FileStatus]:
+        """Load and return current file statuses."""
+        self._status = get_status()
+        return self._status
+
+    @property
+    def staged_files(self) -> list[FileStatus]:
+        """Files with staged changes."""
+        return [f for f in self._status if f.is_staged]
+
+    @property
+    def unstaged_files(self) -> list[FileStatus]:
+        """Files with unstaged changes (including untracked)."""
+        return [f for f in self._status if f.is_unstaged]
+
+    def stage_files(self, paths: list[str]) -> None:
+        """Stage the given file paths."""
+        git_stage(paths)
+
+    def unstage_files(self, paths: list[str]) -> None:
+        """Unstage the given file paths."""
+        git_unstage(paths)
+
+    def get_diff(self, file_status: FileStatus) -> str:
+        """Get diff for a file."""
+        if file_status.is_staged:
+            return get_staged_file_diff(file_status.path)
+        if file_status.index_status == "?" or file_status.worktree_status == "?":
+            return get_untracked_file_diff(file_status.path)
+        return get_file_diff(file_status.path)
+
+    def get_staged_preview(self) -> str:
+        """Get combined diff of all staged changes."""
+        return get_staged_diff()
+
+    def commit(self, message: str) -> CommitResult:
+        """Create a commit with the given message after validation."""
+        cleaned = self._clean_message(message)
+        if not cleaned:
+            return CommitResult(success=False, error="Commit message cannot be empty")
+
+        if not self.staged_files:
+            return CommitResult(success=False, error="No staged changes to commit")
+
+        try:
+            commit_hash = git_commit(cleaned)
+            return CommitResult(success=True, commit_hash=commit_hash)
+        except GitError as exc:
+            return CommitResult(success=False, error=str(exc))
+
+    def push(self) -> PushResult:
+        """Push committed changes to remote."""
+        status = get_remote_status()
+        if not status.remote:
+            return PushResult(success=False, error="No remote configured")
+        if status.behind > 0:
+            return PushResult(
+                success=False,
+                error="Remote has new changes. Pull first.",
+            )
+
+        return git_push(remote=status.remote, branch=status.branch)
+
+    def can_commit(self) -> bool:
+        """Whether commit action is allowed."""
+        state = get_operation_state()               
+        if is_detached_head() or state.in_progress:  
+            return False
+        return len(self.staged_files) > 0
+
+    def can_push(self) -> bool:
+        """Whether push action is allowed."""
+        status = get_remote_status()
+        return status.remote != "" and status.ahead > 0
+
+    @staticmethod
+    def _clean_message(message: str) -> str:
+        """Clean commit message: strip, remove comment lines."""
+        lines = message.strip().splitlines()
+        cleaned = [line for line in lines if not line.lstrip().startswith("#")]
+        return "\n".join(cleaned).strip()

gitux/presenter/repo_presenter.py

@@ -0,0 +1,119 @@
+"""Presenter for repository-level operations (branch, remote, repo info)."""
+
+from gitux.domain import HeadSummary, OperationState, RemoteStatus, RepoInfo
+from gitux.git import (
+    GitError,
+    get_branches as git_get_branches,
+    get_commit_details as git_get_commit_details,
+    get_current_branch,
+    get_commit_log as git_get_commit_log,
+    get_default_branch as git_get_default_branch,
+    get_head_summary as git_get_head_summary,
+    get_operation_state as git_get_operation_state,
+    get_remote_status,
+    get_repo_info,
+    get_user as git_get_user,
+    is_detached_head,
+    is_merge_in_progress as git_is_merge_in_progress,
+    is_rebase_in_progress as git_is_rebase_in_progress,
+    switch_branch as git_switch_branch,
+)
+
+
+class RepoPresenter:
+    """Business logic for repository queries — branch, remote, identity, log. """
+
+    def get_current_branch(self) -> str:
+        """Return current branch name, or empty string on error."""
+        try:
+            return get_current_branch()
+        except GitError:
+            return ""
+
+    def is_detached_head(self) -> bool:
+        """Return True if HEAD is detached, or False on error."""
+        try:
+            return is_detached_head()
+        except GitError:
+            return False
+
+    def get_remote_status(self) -> RemoteStatus | None:
+        """Get ahead/behind status for current branch, or None on error."""
+        try:
+            return get_remote_status()
+        except GitError:
+            return None
+
+    def get_repo_info(self) -> RepoInfo | None:
+        """Get repository identity (name + path), or None on error."""
+        try:
+            return get_repo_info()
+        except GitError:
+            return None
+
+    def get_commit_log(self, count: int = 30) -> str:
+        """Return the ASCII commit log graph, or empty string on error."""
+        try:
+            return git_get_commit_log(count)
+        except GitError:
+            return ""
+
+    def get_commit_details(self, commit_hash: str) -> str:
+        """Return commit detail text (hash/author/date/subject/body/stat), or "" on error."""
+        try:
+            return git_get_commit_details(commit_hash)
+        except GitError:
+            return ""
+
+    def get_branches(self) -> list[str]:
+        """Return local branch names, or [] on error."""
+        try:
+            return git_get_branches()
+        except GitError:
+            return []
+
+    def switch_branch(self, name: str) -> None:
+        """Switch to a local branch. Propagates GitError to the caller."""
+        git_switch_branch(name)
+
+    def get_user(self) -> str:
+        """Return the configured git user, or "" on error."""
+        try:
+            return git_get_user()
+        except GitError:
+            return ""
+
+    def get_head_summary(self) -> HeadSummary | None:
+        """Return the HEAD commit summary, or None on error."""
+        try:
+            return git_get_head_summary()
+        except GitError:
+            return None
+
+    def get_default_branch(self) -> str:
+        """Return the default branch name, or "" on error."""
+        try:
+            return git_get_default_branch()
+        except GitError:
+            return ""
+
+    def get_operation_state(self) -> OperationState | None:
+        """Return the merge/rebase operation state, or None on error."""
+        try:
+            return git_get_operation_state()
+        except GitError:
+            return None
+
+    def is_merge_in_progress(self) -> bool:
+        """Return True if a merge is in progress, or False on error."""
+        try:
+            return git_is_merge_in_progress()
+        except GitError:
+            return False
+
+    def is_rebase_in_progress(self) -> bool:
+        """Return True if a rebase is in progress, or False on error."""
+        try:
+            return git_is_rebase_in_progress()
+        except GitError:
+            return False

gitux/ui/__init__.py

@@ -0,0 +1 @@
+"""Textual TUI components."""