gitux 0.1.0__py3-none-any.whl

gitux/__init__.py

@@ -0,0 +1,3 @@
+"""GITUX - A beautiful, minimalist TUI for Git."""
+
+__version__ = "0.1.0"

gitux/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running GITUX with `python -m gitux`."""
+
+from gitux.cli import main
+
+if __name__ == "__main__":
+    main()

gitux/cli.py

@@ -0,0 +1,35 @@
+"""CLI entry point using Typer."""
+
+from typer import Typer, Option, echo, Exit
+
+app = Typer(
+    name="gitux",
+    help="A beautiful, minimalist TUI for Git.",
+    no_args_is_help=True,
+)
+
+
+@app.command()
+def run(
+    version: bool = Option(False, "--version", "-v", help="Show version and exit"),
+):
+    """Launch the GITUX TUI."""
+    if version:
+        from gitux import __version__
+
+        echo(f"gitux {__version__}")
+        raise Exit()
+
+    from gitux.ui.app import GituxApp
+
+    gitux_app = GituxApp()
+    gitux_app.run()
+
+
+def main() -> None:
+    """Console script entry point."""
+    app()
+
+
+if __name__ == "__main__":
+    main()

gitux/domain/__init__.py

@@ -0,0 +1,27 @@
+"""Domain layer for GITUX."""
+
+from gitux.domain.models import CommitLogEntry
+from gitux.domain.models import CommitResult
+from gitux.domain.models import FileCounts
+from gitux.domain.models import FileStatus
+from gitux.domain.models import HeadSummary
+from gitux.domain.models import OperationState
+from gitux.domain.models import PushResult
+from gitux.domain.models import RemoteStatus
+from gitux.domain.models import RepoInfo
+from gitux.domain.models import WipState
+from gitux.domain.models import derive_wip_state
+
+__all__ = [
+    "CommitLogEntry",
+    "CommitResult",
+    "FileCounts",
+    "FileStatus",
+    "HeadSummary",
+    "OperationState",
+    "PushResult",
+    "RemoteStatus",
+    "RepoInfo",
+    "WipState",
+    "derive_wip_state",
+]

gitux/domain/models.py

@@ -0,0 +1,180 @@
+"""Domain models for GITUX."""
+
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+@dataclass(frozen=True)
+class FileStatus:
+    """Represents the status of a single file in the working tree."""
+
+    index_status: str       
+    worktree_status: str    
+    path: str               
+    old_path: str | None    
+
+    @property
+    def is_staged(self) -> bool:
+        """True if file has staged changes (index_status is not space or ?)."""
+        return self.index_status not in (" ", "?")
+
+    @property
+    def is_unstaged(self) -> bool:
+        """True if file has unstaged changes or is untracked."""
+        return self.worktree_status != " "
+
+    @property
+    def display_status(self) -> str:
+        """Return the primary status character for display."""
+        if self.index_status not in (" ", "?"):
+            return self.index_status
+        return self.worktree_status
+
+    @property
+    def display_path(self) -> str:
+        """Return formatted path, including old->new for renames."""
+        if self.old_path:
+            return f"{self.old_path} -> {self.path}"
+        return self.path
+
+
+@dataclass(frozen=True)
+class CommitResult:
+    """Result of a git commit operation."""
+
+    success: bool
+    commit_hash: str | None = None
+    error: str | None = None
+
+
+@dataclass(frozen=True)
+class PushResult:
+    """Result of a git push operation."""
+
+    success: bool
+    pushed_refs: list[str] = field(default_factory=list)
+    failed_refs: list[tuple[str, str]] = field(default_factory=list)
+    error: str | None = None
+
+
+@dataclass(frozen=True)
+class RepoInfo:
+    """Repository identity extracted from the local clone."""
+
+    name: str       
+    path: str       
+    owner: str = "" 
+
+    @property
+    def display_name(self) -> str:
+        """Human-friendly name for the header."""
+        return self.name or "(no name)"
+
+
+@dataclass(frozen=True)
+class HeadSummary:
+    """Short hash, subject, and epoch-seconds of the HEAD commit (batched log output)."""
+
+    short_hash: str
+    subject: str
+    epoch: int
+
+
+@dataclass(frozen=True)
+class FileCounts:
+    """Partition of the working-tree file count (conflicts excluded from other buckets)."""
+
+    staged: int
+    modified: int
+    untracked: int
+    conflicts: int
+
+    @classmethod
+    def from_status(cls, files: list[FileStatus]) -> "FileCounts":
+        """Partition a status list into staged/modified/untracked/conflicts."""
+
+        staged = modified = untracked = conflicts = 0
+        for f in files:
+            if (
+                f.index_status == "U"
+                or f.worktree_status == "U"
+                or (f.index_status == "A" and f.worktree_status == "A")
+                or (f.index_status == "D" and f.worktree_status == "D")
+            ):
+                conflicts += 1
+            elif f.index_status == "?":
+                untracked += 1
+            elif f.is_staged:
+                staged += 1
+            elif f.worktree_status != " ":
+                modified += 1
+            else:
+                modified += 1
+        return cls(
+            staged=staged,
+            modified=modified,
+            untracked=untracked,
+            conflicts=conflicts,
+        )
+
+
+@dataclass(frozen=True)
+class OperationState:
+    """Merge/rebase in-progress flags from one shared git-dir lookup."""
+
+    merge: bool
+    rebase: bool
+
+    @property
+    def in_progress(self) -> bool:
+        """True if a merge or rebase is currently in progress."""
+        return self.merge or self.rebase
+
+
+class WipState(Enum):
+    """Work-in-progress state rendered as a single colored dot on the top bar."""
+
+    UNKNOWN = "unknown"     
+    CLEAN = "clean"         
+    DIRTY = "dirty"         
+    CONFLICT = "conflict"   
+
+
+def derive_wip_state(file_counts: FileCounts, operation: OperationState | None, has_commits: bool,) -> WipState:
+    """Derive the WIP dot state with locked precedence CONFLICT > UNKNOWN > DIRTY > CLEAN."""
+
+    if operation is None:
+        return WipState.UNKNOWN
+    if operation.in_progress or file_counts.conflicts > 0:
+        return WipState.CONFLICT
+    if not has_commits:
+        return WipState.UNKNOWN
+    if (
+        file_counts.staged > 0
+        or file_counts.modified > 0
+        or file_counts.untracked > 0
+    ):
+        return WipState.DIRTY
+    return WipState.CLEAN
+
+
+@dataclass(frozen=True)
+class CommitLogEntry:
+    """Represents a single entry in the commit log graph."""
+
+    raw_line: str          
+
+
+@dataclass(frozen=True)
+class RemoteStatus:
+    """Current remote tracking status for the active branch."""
+
+    remote: str
+    branch: str
+    ahead: int
+    behind: int
+
+    @property
+    def diverged(self) -> bool:
+        """True if both ahead > 0 and behind > 0."""
+        return self.ahead > 0 and self.behind > 0

gitux/git/__init__.py

@@ -0,0 +1,57 @@
+"""Git infrastructure layer."""
+
+from gitux.git.exceptions import GitError
+from gitux.git.commands import (
+    commit,
+    get_branches,
+    get_commit_details,
+    get_commit_log,
+    get_current_branch,
+    get_default_branch,
+    get_file_diff,
+    get_git_dir,
+    get_head_summary,
+    get_operation_state,
+    get_remote_status,
+    get_repo_info,
+    get_staged_diff,
+    get_staged_file_diff,
+    get_status,
+    get_untracked_file_diff,
+    get_user,
+    is_detached_head,
+    is_merge_in_progress,
+    is_rebase_in_progress,
+    push,
+    stage,
+    switch_branch,
+    unstage,
+)
+
+__all__ = [
+    "GitError",
+    "commit",
+    "get_branches",
+    "get_commit_details",
+    "get_commit_log",
+    "get_current_branch",
+    "get_default_branch",
+    "get_file_diff",
+    "get_git_dir",
+    "get_head_summary",
+    "get_operation_state",
+    "get_remote_status",
+    "get_repo_info",
+    "get_staged_diff",
+    "get_staged_file_diff",
+    "get_status",
+    "get_untracked_file_diff",
+    "get_user",
+    "is_detached_head",
+    "is_merge_in_progress",
+    "is_rebase_in_progress",
+    "push",
+    "stage",
+    "switch_branch",
+    "unstage",
+]

gitux/git/commands.py

@@ -0,0 +1,392 @@
+"""Low-level git command wrappers."""
+
+import os
+import subprocess
+from pathlib import Path
+from urllib.parse import urlparse
+
+from gitux.domain import FileStatus, HeadSummary, OperationState, PushResult, RemoteStatus, RepoInfo
+from gitux.git.exceptions import GitError
+from gitux.git.parser import parse_push_output, parse_status
+
+_TIMEOUT = 30  
+_PUSH_TIMEOUT = 60  
+
+
+def _run(args: list[str], *, timeout: int = _TIMEOUT) -> subprocess.CompletedProcess[str]:
+    """Run a git command and return the result. Raises GitError on failure."""
+    try:
+        result = subprocess.run(
+            ["git", *args],
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+        )
+    except subprocess.TimeoutExpired as exc:
+        raise GitError(f"Git command timed out after {timeout}s") from exc
+    except FileNotFoundError as exc:
+        raise GitError("git is not installed or not found on PATH") from exc
+
+    if result.returncode != 0:
+        raise GitError(
+            f"git {' '.join(args[:3])} failed (exit {result.returncode})",
+            stderr=result.stderr.strip(),
+        )
+    return result
+
+
+def get_status() -> list[FileStatus]:
+    """Return all file statuses using ``git status --porcelain=v1 -z -uall``.
+
+    ``-uall`` expands untracked directories so every file is listed
+    individually — never a collapsed ``dir/`` entry.
+    """
+    result = _run(["status", "--porcelain=v1", "-z", "-uall"])
+    return parse_status(result.stdout)
+
+
+def stage(paths: list[str]) -> None:
+    """Stage files using ``git add``."""
+    if not paths:
+        return
+    _run(["add", "--", *paths])
+
+
+def unstage(paths: list[str]) -> None:
+    """Unstage files using ``git reset HEAD``."""
+    if not paths:
+        return
+    _run(["reset", "HEAD", "--", *paths])
+
+
+def get_staged_diff() -> str:
+    """Return the combined diff of all staged changes."""
+    result = _run(["diff", "--cached"])
+    return result.stdout
+
+
+def get_file_diff(path: str) -> str:
+    """Return the unstaged diff for a single file."""
+    try:
+        result = _run(["diff", "--", path])
+        return result.stdout
+    except GitError:
+        return ""
+
+
+def get_staged_file_diff(path: str) -> str:
+    """Return the staged diff for a single file."""
+    try:
+        result = _run(["diff", "--cached", "--", path])
+        return result.stdout
+    except GitError:
+        return ""
+
+
+def _run_tolerant(args: list[str], *, allowed_return_codes: set[int], timeout: int = _TIMEOUT) -> subprocess.CompletedProcess[str]:
+    """Run git, treating allowed_return_codes as success. Raises GitError otherwise."""
+    try:
+        result = subprocess.run(
+            ["git", *args], 
+            capture_output=True, 
+            text=True, 
+            timeout=timeout,
+        )
+    except subprocess.TimeoutExpired as exc:
+        raise GitError(f"Git command timed out after {timeout}s") from exc
+    except FileNotFoundError as exc:
+        raise GitError("git is not installed or not found on PATH") from exc
+    if result.returncode not in allowed_return_codes:
+        raise GitError(
+            f"git {' '.join(args[:3])} failed (exit {result.returncode})",
+            stderr=result.stderr.strip(),
+        )
+    return result
+
+
+def get_untracked_file_diff(path: str) -> str:
+    """Unified diff of an untracked file vs /dev/null; "" for binary or empty files."""
+    try:
+        result = _run_tolerant(
+            ["diff", "--no-index", "/dev/null", path], allowed_return_codes={0, 1},
+        )
+    except GitError:
+        return ""
+    if "Binary files" in result.stdout:      
+        return ""
+    if not any(line.startswith("@@") for line in result.stdout.splitlines()):
+        return ""                            
+    return result.stdout
+
+
+def commit(message: str) -> str:
+    """Create a commit with the given message. Returns the short hash."""
+    _run(["commit", "-m", message])
+    result = _run(["rev-parse", "--short", "HEAD"])
+    return result.stdout.strip()
+
+
+def push(remote: str = "origin", branch: str = "") -> PushResult:
+    """Push to remote using ``git push --porcelain``. Returns PushResult."""
+    args = ["push", "--porcelain"]
+    if remote:
+        args.append(remote)
+    if branch:
+        args.append(branch)
+
+    try:
+        result = subprocess.run(
+            ["git", *args],
+            capture_output=True,
+            text=True,
+            timeout=_PUSH_TIMEOUT,
+        )
+    except subprocess.TimeoutExpired:
+        return PushResult(success=False, error="Push timed out")
+    except FileNotFoundError as exc:
+        return PushResult(success=False, error=str(exc))
+
+    ok_refs, failed_refs = parse_push_output(result.stdout)
+
+    if result.returncode != 0 and not failed_refs:
+        failed_refs.append(("refs/*", result.stderr.strip() or "push failed"))
+
+    return PushResult(
+        success=result.returncode == 0,
+        pushed_refs=ok_refs,
+        failed_refs=failed_refs,
+        error=result.stderr.strip() if result.returncode != 0 else None,
+    )
+
+
+def get_current_branch() -> str:
+    """Return the name of the current branch.
+
+    Empty repo -> "main" (exit 0); detached HEAD -> "" (exit 0).
+    """
+    result = _run(["branch", "--show-current"])
+    return result.stdout.strip()
+
+
+def _extract_repo_name(url: str) -> str:
+    """Extract the repository name from a remote URL."""
+    parsed = urlparse(url)
+    if parsed.path:
+        name = parsed.path.rsplit("/", 1)[-1]
+    else:
+        name = url.rsplit("/", 1)[-1]
+
+    if name.endswith(".git"):
+        name = name[:-4]
+
+    return name
+
+
+def _extract_owner(url: str) -> str:
+    """Extract the repository owner from a remote URL."""
+    parsed = urlparse(url)
+    if parsed.scheme in ("https", "http"):
+        segments = [s for s in parsed.path.split("/") if s]
+        if len(segments) >= 2:
+            return segments[-2]
+        return ""
+
+    if ":" in url:
+        path_part = url.rsplit(":", 1)[-1]
+        segments = [s for s in path_part.split("/") if s]
+        if len(segments) >= 2:
+            return segments[-2]
+    return ""
+
+
+def get_repo_info() -> RepoInfo:
+    """Return repository identity (name + owner + absolute working-tree path)."""
+    toplevel = _run(["rev-parse", "--show-toplevel"]).stdout.strip()
+
+    name = ""
+    owner = ""
+    try:
+        url = _run(["remote", "get-url", "origin"]).stdout.strip()
+        name = _extract_repo_name(url)
+        owner = _extract_owner(url)
+    except GitError:
+        try:
+            result = _run(["remote"])
+            remotes = result.stdout.strip().splitlines()
+            if remotes:
+                url = _run(["remote", "get-url", remotes[0]]).stdout.strip()
+                name = _extract_repo_name(url)
+                owner = _extract_owner(url)
+        except GitError:
+            pass
+
+    if not name and toplevel:
+        name = Path(toplevel).name
+
+    return RepoInfo(name=name, path=toplevel, owner=owner)
+
+
+def get_remote_status() -> RemoteStatus:
+    """Return ahead/behind counts and tracking info for the current branch."""
+    branch = get_current_branch()
+
+    try:
+        result = _run([
+            "rev-parse", "--abbrev-ref", f"{branch}@{{upstream}}"
+        ])
+        upstream = result.stdout.strip()
+        remote, _, upstream_branch = upstream.partition("/")
+    except GitError:
+        return RemoteStatus(remote="", branch=branch, ahead=0, behind=0)
+
+    try:
+        result = _run([
+            "rev-list", "--left-right", "--count",
+            f"{branch}...{upstream}",
+        ])
+        counts = result.stdout.strip().split("\t")
+        ahead = int(counts[0]) if len(counts) > 0 else 0
+        behind = int(counts[1]) if len(counts) > 1 else 0
+    except (GitError, ValueError):
+        ahead, behind = 0, 0
+
+    return RemoteStatus(
+        remote=remote,
+        branch=upstream_branch,
+        ahead=ahead,
+        behind=behind,
+    )
+
+
+def get_branches() -> list[str]:
+    """Return list of local branch names from ``git branch``."""
+    result = _run(["branch"])
+    branches = [line.strip() for line in result.stdout.splitlines() if line.strip()]
+    cleaned = []
+    for b in branches:
+        name = b[2:] if b.startswith("* ") else b
+        if name.startswith("("):
+            continue
+        cleaned.append(name)
+    return cleaned
+
+
+def switch_branch(name: str) -> None:
+    """Switch to a local branch via ``git switch``. Raises GitError on failure."""
+    _run(["switch", name])
+
+
+def get_commit_log(count: int = 30) -> str:
+    """Return the commit log with ASCII graph via ``git log --all --oneline --graph --decorate``."""
+    result = _run(["log", "--all", "--oneline", "--graph", "--decorate", f"-{count}"])
+    return result.stdout
+
+
+_COMMIT_DETAILS_FORMAT = "%h %an <%ae>%n%ad%n%n%s%n%n%b"
+
+
+def get_commit_details(commit_hash: str) -> str:
+    """Return commit metadata + --stat summary via `git show`. Raises GitError on failure."""
+    result = _run([
+        "show", f"--format={_COMMIT_DETAILS_FORMAT}", "--stat", "--date=iso", commit_hash,
+    ])
+    return result.stdout
+
+
+def is_detached_head() -> bool:
+    """Return True if HEAD is detached."""
+    try:
+        _run(["symbolic-ref", "-q", "HEAD"], timeout=5)
+        return False
+    except GitError:
+        return True
+
+
+def _try_config(key: str) -> str:
+    """Return a git config value, or "" on any git error."""
+    try:
+        return _run(["config", "--get", key]).stdout.strip()
+    except GitError:
+        return ""
+
+
+def _os_login() -> str:
+    """Return the OS login name, falling back to $USER on failure."""
+    try:
+        return os.getlogin()
+    except OSError:
+        return os.environ.get("USER", "")
+
+
+def get_user() -> str:
+    """Return the configured git user (name -> email -> OS login). Never raises."""
+    name = _try_config("user.name")
+    if name:
+        return name
+    email = _try_config("user.email")
+    if email:
+        return email
+    return _os_login()
+
+
+def get_head_summary() -> HeadSummary | None:
+    """Return short hash, subject, and epoch of HEAD, or None when malformed.
+
+    ``GitError`` propagates for empty repos (exit 128) — the presenter converts.
+    """
+    result = _run(["log", "-1", "--format=%h%x09%s%x09%ct"])
+    parts = result.stdout.strip().split("\t")
+    if len(parts) < 3:
+        return None
+    try:
+        epoch = int(parts[2])
+    except ValueError:
+        return None
+    return HeadSummary(short_hash=parts[0], subject=parts[1], epoch=epoch)
+
+
+def get_default_branch() -> str:
+    """Return the default branch name from a single ``git branch -r`` call.
+
+    Parses stripped lines in order: an ``origin/HEAD -> origin/<name>`` line wins;
+    otherwise the ``origin/main``/``origin/master`` convention; else ``""``.
+    Never mutates, never touches the network.
+    """
+    result = _run(["branch", "-r"])
+    lines = [line.strip() for line in result.stdout.splitlines()]
+    for line in lines:
+        if line.startswith("origin/HEAD") and " -> " in line:
+            target = line.split(" -> ", 1)[-1].strip()
+            if target.startswith("origin/"):
+                return target[len("origin/"):]
+    if "origin/main" in lines:
+        return "main"
+    if "origin/master" in lines:
+        return "master"
+    return ""
+
+
+def get_git_dir() -> str:
+    """Return the git directory path via ``git rev-parse --git-dir``."""
+    return _run(["rev-parse", "--git-dir"]).stdout.strip()
+
+
+def get_operation_state() -> OperationState:
+    """Return merge/rebase in-progress flags from one shared git-dir lookup."""
+    git_dir = Path(get_git_dir())
+    return OperationState(
+        merge=(git_dir / "MERGE_HEAD").exists(),
+        rebase=(git_dir / "rebase-merge").exists()
+        or (git_dir / "rebase-apply").exists(),
+    )
+
+
+def is_merge_in_progress() -> bool:
+    """Return True if a merge is in progress."""
+    return (Path(get_git_dir()) / "MERGE_HEAD").exists()
+
+
+def is_rebase_in_progress() -> bool:
+    """Return True if a rebase is in progress."""
+    git_dir = Path(get_git_dir())
+    return (git_dir / "rebase-merge").exists() or (git_dir / "rebase-apply").exists()