gitux 0.1.0__tar.gz → 0.2.0__tar.gz

gitux-0.2.0/.github/workflows/ci.yml

@@ -0,0 +1,56 @@
+name: CI
+
+on:
+  push:
+    branches: [master, develop]
+  pull_request:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          enable-cache: true
+
+      - name: Install dependencies
+        run: uv sync --all-extras
+
+      - name: Run tests
+        run: uv run pytest -q
+
+  build:
+    needs: [test]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          python-version: "3.12"
+          enable-cache: true
+
+      - name: Build package
+        run: uv build
+
+      - name: Upload distributions
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/

{gitux-0.1.0 → gitux-0.2.0}/.gitignore

@@ -15,4 +15,8 @@ DESIGN.md
 
 # Opencode
 .opencode/
-AGENTS.md
+AGENTS.md
+
+# Metrics
+.scannerwork
+sonar-project.properties

{gitux-0.1.0 → gitux-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: gitux
-Version: 0.1.0
+Version: 0.2.0
 Summary: A beautiful, minimalist TUI for Git.
 Project-URL: Homepage, https://github.com/Hector-2710/gitux
 Project-URL: Repository, https://github.com/Hector-2710/gitux
@@ -104,7 +104,7 @@ gitux --version
 
 | Key | Action |
 |-----|--------|
-| `Tab` | Next section (Files / Commits / Diff) |
+| `Tab` | Next section (Files / Diff) |
 | `↑` / `↓` or `j` / `k` | Scroll active section |
 | `s` / `Enter` | Stage / unstage file |
 | `a` / `A` | Stage all / unstage all files |
@@ -113,6 +113,7 @@ gitux --version
 | `Ctrl+p` | Push to remote |
 | `r` | Refresh status |
 | `b` | Branches panel |
+| `l` | Commit log (overlay) |
 | `?` | Show help |
 | `q` | Quit GITUX |
 

{gitux-0.1.0 → gitux-0.2.0}/README.md

@@ -73,7 +73,7 @@ gitux --version
 
 | Key | Action |
 |-----|--------|
-| `Tab` | Next section (Files / Commits / Diff) |
+| `Tab` | Next section (Files / Diff) |
 | `↑` / `↓` or `j` / `k` | Scroll active section |
 | `s` / `Enter` | Stage / unstage file |
 | `a` / `A` | Stage all / unstage all files |
@@ -82,6 +82,7 @@ gitux --version
 | `Ctrl+p` | Push to remote |
 | `r` | Refresh status |
 | `b` | Branches panel |
+| `l` | Commit log (overlay) |
 | `?` | Show help |
 | `q` | Quit GITUX |
 

{gitux-0.1.0 → gitux-0.2.0}/pyproject.toml

@@ -55,3 +55,6 @@ packages = ["src/gitux"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
+
+[tool.basedpyright]
+reportUnusedCallResult = "none"

{gitux-0.1.0 → gitux-0.2.0}/scripts/benchmark.py

@@ -234,8 +234,8 @@ async def _run_app_headless() -> None:
     from gitux.ui.app import GituxApp
 
     app = GituxApp()
-    async with app.run_test(headless=True):
-        pass
+    async with app.run_test(headless=True) as pilot:
+        await pilot.pause()  # ensure first render completes before exiting
 
 
 def _benchmark_startup() -> float:

{gitux-0.1.0 → gitux-0.2.0}/src/gitux/__init__.py

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

{gitux-0.1.0 → gitux-0.2.0}/src/gitux/git/__init__.py

@@ -1,30 +1,38 @@
 """Git infrastructure layer."""
 
 from gitux.git.exceptions import GitError
-from gitux.git.commands import (
-    commit,
+from gitux.git.branch import (
     get_branches,
-    get_commit_details,
-    get_commit_log,
     get_current_branch,
     get_default_branch,
-    get_file_diff,
-    get_git_dir,
+    is_detached_head,
+    switch_branch,
+)
+from gitux.git.commit import (
+    commit,
+    get_commit_details,
+    get_commit_log,
     get_head_summary,
-    get_operation_state,
+)
+from gitux.git.config import get_user
+from gitux.git.remote import (
     get_remote_status,
     get_repo_info,
+    push,
+)
+from gitux.git.repo import (
+    get_git_dir,
+    get_operation_state,
+    is_merge_in_progress,
+    is_rebase_in_progress,
+)
+from gitux.git.status import (
+    get_file_diff,
     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,
 )
 
@@ -54,4 +62,4 @@ __all__ = [
     "stage",
     "switch_branch",
     "unstage",
-]
+]

gitux-0.2.0/src/gitux/git/branch.py

@@ -0,0 +1,61 @@
+"""Branch-related git commands."""
+
+from gitux.git.exceptions import GitError
+from gitux.git.runner import _run
+
+
+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 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 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 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 ""

gitux-0.2.0/src/gitux/git/commands.py

@@ -0,0 +1,91 @@
+"""Backward-compatible re-exports of the git command wrappers.
+
+The wrappers were split into domain modules (``runner``, ``status``, ``commit``,
+``branch``, ``remote``, ``repo``, ``config``) to reduce per-file complexity.
+This module exists only so that ``from gitux.git.commands import ...`` keeps
+working; prefer importing from ``gitux.git`` directly.
+"""
+
+from gitux.git.branch import (
+    get_branches,
+    get_current_branch,
+    get_default_branch,
+    is_detached_head,
+    switch_branch,
+)
+from gitux.git.commit import (
+    _COMMIT_DETAILS_FORMAT,
+    commit,
+    get_commit_details,
+    get_commit_log,
+    get_head_summary,
+)
+from gitux.git.config import (
+    _os_login,
+    _try_config,
+    get_user,
+)
+from gitux.git.remote import (
+    _extract_owner,
+    _extract_repo_name,
+    _PUSH_TIMEOUT,
+    get_remote_status,
+    get_repo_info,
+    push,
+)
+from gitux.git.repo import (
+    get_git_dir,
+    get_operation_state,
+    is_merge_in_progress,
+    is_rebase_in_progress,
+)
+from gitux.git.runner import (
+    _TIMEOUT,
+    _run,
+    _run_tolerant,
+)
+from gitux.git.status import (
+    get_file_diff,
+    get_staged_diff,
+    get_staged_file_diff,
+    get_status,
+    get_untracked_file_diff,
+    stage,
+    unstage,
+)
+
+__all__ = [
+    "_COMMIT_DETAILS_FORMAT",
+    "_PUSH_TIMEOUT",
+    "_TIMEOUT",
+    "_extract_owner",
+    "_extract_repo_name",
+    "_os_login",
+    "_run",
+    "_run_tolerant",
+    "_try_config",
+    "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-0.2.0/src/gitux/git/commit.py

@@ -0,0 +1,43 @@
+"""Commit-related git commands."""
+
+from gitux.domain import HeadSummary
+from gitux.git.runner import _run
+
+_COMMIT_DETAILS_FORMAT = "%h %an <%ae>%n%ad%n%n%s%n%n%b"
+
+
+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 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
+
+
+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 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)

gitux-0.2.0/src/gitux/git/config.py

@@ -0,0 +1,33 @@
+"""Git user configuration commands."""
+
+import os
+
+from gitux.git.exceptions import GitError
+from gitux.git.runner import _run
+
+
+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()

{gitux-0.1.0 → gitux-0.2.0}/src/gitux/git/parser.py

@@ -8,7 +8,10 @@ def parse_status(raw: str) -> list[FileStatus]:
 
     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)
+        XY<SPACE>new<NUL>old<NUL>        # rename/copy (XY + space + new path, then old path)
+
+    Note: in the ``-z`` format git reverses the rename field order shown in the
+    human format (``from -> to`` becomes ``to`` ``from``) and omits the score.
     """
     if not raw:
         return []
@@ -29,27 +32,10 @@ def parse_status(raw: str) -> list[FileStatus]:
         index_status = part[0]
         worktree_status = part[1]
 
-        path = part[3:]  # Skip XY (2 chars) + space (1 char)
+        path = part[3:]  # Skip XY (2 chars) + space (1 char); for renames this is the new path
 
         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,
-            ))
+            i = _parse_rename_entry(parts, i, index_status, worktree_status, path, entries)
         else:
             i += 1
             entries.append(FileStatus(
@@ -62,6 +48,28 @@ def parse_status(raw: str) -> list[FileStatus]:
     return entries
 
 
+def _parse_rename_entry(
+    parts: list[str],
+    i: int,
+    index_status: str,
+    worktree_status: str,
+    new_path: str,
+    entries: list[FileStatus],
+) -> int:
+    """Parse a rename/copy entry, append it to ``entries``, and return the next index."""
+    # ``new_path`` is the destination; the next part holds the old (source) path.
+    i += 1
+    old_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,
+    ))
+    return i
+
+
 def parse_push_output(raw: str) -> tuple[list[str], list[tuple[str, str]]]:
     """Parse output of ``git push --porcelain``.
 

gitux-0.2.0/src/gitux/git/remote.py

@@ -0,0 +1,136 @@
+"""Remote, push, and repository-identity commands."""
+
+import subprocess
+from pathlib import Path
+from urllib.parse import urlparse
+
+from gitux.domain import PushResult, RemoteStatus, RepoInfo
+from gitux.git.branch import get_current_branch
+from gitux.git.exceptions import GitError
+from gitux.git.parser import parse_push_output
+from gitux.git.runner import _run
+
+_PUSH_TIMEOUT = 60
+
+
+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 _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,
+    )

gitux-0.2.0/src/gitux/git/repo.py

@@ -0,0 +1,32 @@
+"""Repository state commands (git dir, in-progress operations)."""
+
+from pathlib import Path
+
+from gitux.domain import OperationState
+from gitux.git.runner import _run
+
+
+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()