gitwise-cli 0.24.2__py3-none-any.whl

gitwise/_paths.py

@@ -0,0 +1,22 @@
+"""Centralized path resolution for share/ data directory.
+
+Resolves the share/ directory location for both installed (pip) and
+development (repo root) environments.
+"""
+
+from pathlib import Path
+
+_PACKAGE_DIR = Path(__file__).resolve().parent
+
+
+def share_dir() -> Path:
+    """Resolve the share/ directory.
+
+    When installed via pip (hatchling force-include), share/ lives inside
+    the package at gitwise/share/. When running from a repo checkout,
+    share/ is a sibling of the package directory at project root.
+    """
+    installed = _PACKAGE_DIR / "share"
+    if installed.is_dir():
+        return installed
+    return _PACKAGE_DIR.parent / "share"

gitwise/_runtime_config.py

@@ -0,0 +1,246 @@
+"""Runtime configuration: immutable settings detected from environment at import time."""
+
+import os
+import select
+import shutil
+import sys
+
+if sys.platform != "win32":
+    import termios
+else:
+    termios = None  # type: ignore[assignment,misc]
+from .design import ColorDepth, ThemeTokens, build_theme
+
+_BRIGHTNESS_THRESHOLD = 0.5
+_OSC_TIMEOUT = 0.5
+
+
+def _drain_fd(fd: int, timeout: float = 0.1) -> None:
+    while True:
+        ready, _, _ = select.select([fd], [], [], timeout)
+        if not ready:
+            break
+        try:
+            os.read(fd, 256)
+        except OSError:
+            break
+
+
+def _query_bg_color() -> str | None:
+    if os.environ.get("NO_COLOR", "") != "":
+        return None
+    if os.environ.get("GITWISE_NO_COLOR", "").lower() in ("1", "true"):
+        return None
+    term = os.environ.get("TERM", "")
+    if term.startswith(("screen", "tmux", "dumb")):
+        return None
+    if not sys.stdout.isatty():
+        return None
+    try:
+        fd = os.open("/dev/tty", os.O_RDWR | os.O_NOCTTY)
+    except OSError:
+        return None
+    try:
+        if termios is None:
+            return None
+        old = termios.tcgetattr(fd)
+        new = list(old)
+        new[3] = new[3] & ~(termios.ECHO | termios.ICANON)
+        termios.tcsetattr(fd, termios.TCSADRAIN, new)
+        try:
+            os.write(fd, b"\x1b]11;?\x1b\\")
+            resp = _read_osc_response(fd)
+        finally:
+            termios.tcsetattr(fd, termios.TCSADRAIN, old)
+        _drain_fd(fd)
+        if resp is None:
+            return None
+        return _parse_osc_color(resp)
+    except (OSError, ValueError):
+        return None
+    finally:
+        try:
+            os.close(fd)
+        except OSError as e:
+            if os.environ.get("GITWISE_DEBUG", "").lower() in ("1", "true"):
+                sys.stderr.write(f"[gitwise debug] tty close failed: {e}\n")
+
+
+def _read_osc_response(fd: int) -> str | None:
+    buf = bytearray()
+    osc_received = False
+    while len(buf) < 50:
+        ready, _, _ = select.select([fd], [], [], _OSC_TIMEOUT)
+        if not ready:
+            break
+        try:
+            ch = os.read(fd, 1)
+        except OSError:
+            break
+        if not ch:
+            break
+        buf.extend(ch)
+        decoded = buf.decode("ascii", errors="ignore")
+        if "\x1b]" in decoded and not osc_received:
+            osc_received = True
+        if osc_received:
+            if decoded.endswith("\x1b\\") or decoded.endswith("\x07"):
+                return decoded
+            if "\x1b[" in decoded[decoded.index("\x1b]") + 1 :]:
+                return decoded[: decoded.index("\x1b[", decoded.index("\x1b]") + 1)]
+    return None
+
+
+def _parse_osc_color(resp: str) -> str | None:
+    idx = resp.find("\x1b]")
+    if idx == -1:
+        return None
+    after_osc = resp[idx + 2 :]
+    semicolon = after_osc.find(";")
+    if semicolon == -1:
+        return None
+    color_part = after_osc[semicolon + 1 :]
+    color_part = color_part.rstrip("\x07").rstrip("\x1b\\").strip()
+    for terminator in ("\x1b[", "\x1b"):
+        tidx = color_part.find(terminator)
+        if tidx >= 0:
+            color_part = color_part[:tidx]
+    if color_part.startswith("rgb:"):
+        parts = color_part[4:].split("/")
+        if len(parts) == 3:
+            r, g, b = (
+                _parse_rgb_component(parts[0]),
+                _parse_rgb_component(parts[1]),
+                _parse_rgb_component(parts[2]),
+            )
+            return f"#{r:02x}{g:02x}{b:02x}"
+    elif color_part.startswith("#"):
+        clean = color_part.rstrip()
+        for terminator in ("\x1b[", "\x1b"):
+            tidx = clean.find(terminator)
+            if tidx >= 0:
+                clean = clean[:tidx]
+        return clean
+    return None
+
+
+def _parse_rgb_component(s: str) -> int:
+    val = int(s, 16)
+    if len(s) > 2:
+        val = val >> (4 * (len(s) - 2))
+    return val & 0xFF
+
+
+def _relative_luminance(hex_color: str) -> float:
+    h = hex_color.lstrip("#")
+    r, g, b = int(h[0:2], 16) / 255, int(h[2:4], 16) / 255, int(h[4:6], 16) / 255
+
+    def linearize(c: float) -> float:
+        return c / 12.92 if c <= 0.04045 else ((c + 0.055) / 1.055) ** 2.4
+
+    return 0.2126 * linearize(r) + 0.7152 * linearize(g) + 0.0722 * linearize(b)
+
+
+def _is_dark_background(bg_hex: str) -> bool:
+    return _relative_luminance(bg_hex) < _BRIGHTNESS_THRESHOLD
+
+
+class RuntimeConfig:
+    __slots__ = (
+        "_theme_tokens",
+        "color_depth",
+        "debug",
+        "has_bat",
+        "has_delta",
+        "is_tty",
+        "terminal_width",
+        "theme",
+    )
+
+    _theme_tokens: ThemeTokens
+    color_depth: ColorDepth
+    debug: bool
+    has_bat: bool
+    has_delta: bool
+    is_tty: bool
+    terminal_width: int
+    theme: str
+
+    def __init__(self) -> None:
+        self.has_bat = bool(shutil.which("bat"))
+        self.has_delta = bool(shutil.which("delta"))
+        self.theme = self._detect_theme()
+        self.is_tty = sys.stdout.isatty()
+        self.debug = os.environ.get("GITWISE_DEBUG", "").lower() in ("1", "true")
+        self.terminal_width = self._detect_terminal_width()
+        self.color_depth = self._detect_color_depth()
+        self._theme_tokens = build_theme(self.theme)
+
+    @property
+    def theme_tokens(self) -> ThemeTokens:
+        return self._theme_tokens
+
+    @staticmethod
+    def _detect_theme() -> str:
+        explicit = os.environ.get("GITWISE_THEME", "").lower()
+        if explicit in ("dark", "light"):
+            return explicit
+
+        cli_theme = os.environ.get("CLITHEME", "").split(":")[0].lower()
+        if cli_theme in ("dark", "light"):
+            return cli_theme
+
+        bg_hex = _query_bg_color()
+        if bg_hex is not None:
+            return "dark" if _is_dark_background(bg_hex) else "light"
+
+        colorfgbg = os.environ.get("COLORFGBG", "")
+        if colorfgbg:
+            parts = colorfgbg.split(";")
+            if len(parts) >= 2:
+                bg = parts[-1]
+                if bg in ("0", "8", "16"):
+                    return "dark"
+                return "light"
+
+        fg_bg = os.environ.get("FG_BG", "")
+        if fg_bg:
+            parts = fg_bg.split(";")
+            if len(parts) >= 2:
+                bg = parts[-1]
+                if bg in ("0", "8", "16"):
+                    return "dark"
+                return "light"
+
+        return "dark"
+
+    @staticmethod
+    def _detect_terminal_width() -> int:
+        from .design import MAX_WIDTH, MIN_WIDTH, detect_terminal_width
+
+        env_width = os.environ.get("GITWISE_WIDTH", "")
+        if env_width.isdigit():
+            w = int(env_width)
+            return max(MIN_WIDTH, min(w, MAX_WIDTH))
+        return detect_terminal_width()
+
+    @staticmethod
+    def _detect_color_depth() -> ColorDepth:
+        from .design import detect_color_depth
+
+        return detect_color_depth()
+
+
+_runtime_config: RuntimeConfig | None = None
+
+
+def get_runtime_config() -> RuntimeConfig:
+    global _runtime_config
+    if _runtime_config is None:
+        _runtime_config = RuntimeConfig()
+    return _runtime_config
+
+
+def reset_runtime_config() -> None:
+    global _runtime_config
+    _runtime_config = None

gitwise/audit.py

@@ -0,0 +1,338 @@
+"""Read-only repo diagnostics with human/JSON dual output."""
+
+import platform
+import shutil
+import subprocess
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from .git import (
+    gpg_status,
+    has_commit_graph,
+    has_remote,
+    has_upstream,
+    require_root,
+    stale_branches,
+)
+from .git import run as git_run
+from .i18n import t
+from .output import (
+    debug,
+    ok,
+    print_blank,
+    print_bracket,
+    print_dim,
+    print_error_styled,
+    print_header,
+    print_json,
+    status,
+)
+
+_STALE_DAYS = 30
+_LARGE_BLOB_MIN_BYTES = 1_000_000  # 1MB
+
+
+def _check_fsmonitor(cwd: Path) -> bool:
+    r = git_run(["config", "--get", "core.fsmonitor"], cwd=cwd, check=False)
+    return r.returncode == 0 and r.stdout.strip().lower() in ("true", "1")
+
+
+def _find_old_stashes(cwd: Path) -> list[dict]:
+    r = git_run(
+        ["reflog", "show", "--format=%gd|%ci|%gs", "stash"],
+        cwd=cwd,
+        check=False,
+    )
+    if r.returncode != 0 or not r.stdout.strip():
+        return []
+    now = datetime.now(timezone.utc)
+    old: list[dict] = []
+    for line in r.stdout.splitlines():
+        parts = line.split("|", 2)
+        if len(parts) < 3:
+            continue
+        ref, date_str, subject = parts
+        try:
+            date = datetime.strptime(date_str.strip(), "%Y-%m-%d %H:%M:%S %z")
+            if date.tzinfo is None:
+                date = date.replace(tzinfo=timezone.utc)
+            age = (now - date).days
+            if age >= _STALE_DAYS:
+                old.append({"ref": ref.strip(), "age_days": age, "subject": subject.strip()})
+        except (ValueError, TypeError):
+            debug(f"stash date parse failed: {line!r}")
+            continue
+    return old
+
+
+def _find_large_blobs(cwd: Path, top_n: int = 3) -> list[dict]:
+    if git_run(["rev-parse", "HEAD"], cwd=cwd, check=False).returncode != 0:
+        return []
+    r = git_run(["ls-tree", "-r", "--long", "HEAD"], cwd=cwd, check=False)
+    if r.returncode != 0:
+        return []
+    blobs: list[dict] = []
+    for line in r.stdout.splitlines():
+        parts = line.split()
+        if len(parts) < 5:
+            continue
+        try:
+            size = int(parts[3])
+            path = " ".join(parts[4:])
+            if size >= _LARGE_BLOB_MIN_BYTES:
+                blobs.append({"path": path, "size": size, "size_mb": round(size / 1_048_576, 2)})
+        except (ValueError, IndexError):
+            debug(f"ls-tree line parse failed: {line!r}")
+            continue
+    blobs.sort(key=lambda b: b["size"], reverse=True)
+    return blobs[:top_n]
+
+
+def _check_mixed_staging(cwd: Path) -> bool:
+    r = git_run(["status", "--porcelain"], cwd=cwd, check=False)
+    if r.returncode != 0:
+        return False
+    has_staged = has_unstaged = False
+    for line in r.stdout.splitlines():
+        if len(line) >= 2:
+            if line[0] not in (" ", "?", "!"):
+                has_staged = True
+            if line[1] not in (" ", "?", "!"):
+                has_unstaged = True
+    return has_staged and has_unstaged
+
+
+def _run_git_sizer(cwd: Path) -> dict | None:
+    if not shutil.which("git-sizer"):
+        return None
+    r = subprocess.run(
+        ["git-sizer", "--threshold=2", "--json"],
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if r.returncode not in (0, 1):
+        return None
+    import json
+
+    try:
+        return json.loads(r.stdout)
+    except (json.JSONDecodeError, ValueError):
+        return None
+
+
+def _check_gpg_findings(gpg: dict) -> list[dict]:
+    if gpg["gpgsign_enabled"] and not gpg["gpg_binary"]:
+        return [
+            {
+                "type": "gpg_binary_missing",
+                "severity": "high",
+                "message": t("gpg_binary_missing_audit"),
+                "fix": t("gpg_binary_missing_fix"),
+                "cost_of_fix": t("trivial"),
+                "cost_of_ignore": t("gpg_binary_missing_cost"),
+            }
+        ]
+    if gpg["gpgsign_enabled"] and not gpg["signing_key_set"]:
+        return [
+            {
+                "type": "gpg_key_missing",
+                "severity": "high",
+                "message": t("gpg_key_missing_audit"),
+                "fix": t("gpg_key_missing_fix"),
+                "cost_of_fix": t("trivial"),
+                "cost_of_ignore": t("gpg_key_missing_cost"),
+            }
+        ]
+    if not gpg["gpgsign_enabled"]:
+        return [
+            {
+                "type": "gpg_not_configured",
+                "severity": "info",
+                "message": t("gpg_not_configured_audit"),
+                "fix": t("gpg_not_configured_fix"),
+                "cost_of_fix": t("gpg_not_configured_fix_cost"),
+                "cost_of_ignore": t("gpg_not_configured_cost"),
+            }
+        ]
+    return []
+
+
+_SEVERITY_ICON = {"critical": "🔴", "high": "🟠", "medium": "🟡", "low": "🔵", "info": "ℹ️"}
+
+
+def run_audit(*, quick: bool = False, as_json: bool = False) -> int:
+    root, err = require_root()
+    if err:
+        return err
+    if root is None:
+        return 1
+    cwd = root
+
+    findings: list[dict[str, Any]] = []
+
+    gpg = gpg_status(cwd)
+    findings.extend(_check_gpg_findings(gpg))
+
+    stale = stale_branches(cwd)
+    if stale:
+        findings.append(
+            {
+                "type": "stale_branches",
+                "severity": "medium",
+                "count": len(stale),
+                "branches": stale,
+                "message": t("stale_branches_audit", count=str(len(stale))),
+                "fix": t("clean_fix"),
+                "cost_of_fix": t("stale_branches_fix_cost"),
+                "cost_of_ignore": t("stale_branches_cost"),
+            }
+        )
+
+    has_commit_graph_val = has_commit_graph(cwd)
+    if not has_commit_graph_val:
+        findings.append(
+            {
+                "type": "missing_commit_graph",
+                "severity": "medium",
+                "message": t("commit_graph_ausente"),
+                "fix": t("commit_graph_fix"),
+                "cost_of_fix": t("commit_graph_fix_cost"),
+                "cost_of_ignore": t("commit_graph_cost"),
+            }
+        )
+
+    if platform.system() == "Darwin":
+        if not _check_fsmonitor(cwd):
+            findings.append(
+                {
+                    "type": "fsmonitor_disabled",
+                    "severity": "low",
+                    "message": t("fsmonitor_disabled"),
+                    "fix": t("fsmonitor_fix"),
+                    "cost_of_fix": t("fsmonitor_fix_cost"),
+                    "cost_of_ignore": t("fsmonitor_cost"),
+                }
+            )
+
+    with status(t("status_audit_stashes")):
+        old_stashes = _find_old_stashes(cwd)
+    if old_stashes:
+        findings.append(
+            {
+                "type": "old_stashes",
+                "severity": "low",
+                "count": len(old_stashes),
+                "stashes": old_stashes,
+                "message": t(
+                    "old_stashes_msg", count=str(len(old_stashes)), days=str(_STALE_DAYS)
+                ),
+                "fix": t("stash_fix"),
+                "cost_of_fix": t("stash_fix_cost"),
+                "cost_of_ignore": t("stash_cost"),
+            }
+        )
+
+    large_blobs: list[dict] = []
+    if not quick:
+        with status(t("status_audit_blobs")):
+            large_blobs = _find_large_blobs(cwd)
+        if large_blobs:
+            findings.append(
+                {
+                    "type": "large_blobs",
+                    "severity": "low",
+                    "count": len(large_blobs),
+                    "blobs": large_blobs,
+                    "message": t("large_blobs", count=str(len(large_blobs))),
+                    "fix": t("large_blobs_fix"),
+                    "cost_of_fix": t("large_blobs_fix_cost"),
+                    "cost_of_ignore": t("large_blobs_cost"),
+                }
+            )
+
+    if _check_mixed_staging(cwd):
+        findings.append(
+            {
+                "type": "mixed_staging",
+                "severity": "info",
+                "message": t("mixed_staging"),
+                "fix": t("mixed_staging_fix"),
+                "cost_of_fix": t("mixed_staging_fix_cost"),
+                "cost_of_ignore": t("mixed_staging_cost"),
+            }
+        )
+
+    if quick:
+        sizer = None
+    else:
+        with status(t("status_audit_sizer")):
+            sizer = _run_git_sizer(cwd)
+
+    _has_remote = has_remote(cwd)
+    _has_upstream = has_upstream(cwd)
+    if _has_remote and not _has_upstream:
+        findings.append(
+            {
+                "type": "no_upstream",
+                "severity": "low",
+                "message": t("no_upstream_audit"),
+                "fix": t("no_upstream_fix"),
+                "cost_of_ignore": t("trivial"),
+            }
+        )
+
+    from .health import compute_health
+
+    health = compute_health(
+        cwd,
+        _gpg_override=gpg,
+        _has_commit_graph=has_commit_graph_val,
+        _has_remote=_has_remote,
+        _has_upstream=_has_upstream,
+        _stale_branches=stale,
+    )
+
+    has_issues = any(f["severity"] in ("critical", "high", "medium") for f in findings)
+
+    result: dict[str, Any] = {
+        "v": 2,
+        "ok": not has_issues,
+        "quick": quick,
+        "findings": findings,
+        "summary": {
+            "stale_branches": len(stale),
+            "commit_graph": has_commit_graph_val,
+            "old_stashes": len(old_stashes),
+            "large_blobs": len(large_blobs),
+            "gpg_ready": gpg["ready"],
+        },
+        "git_sizer": sizer,
+        "health": {"score": health["score"], "grade": health["grade"]},
+    }
+
+    if as_json:
+        print_json(result)
+        return 0 if not has_issues else 1
+
+    if not findings:
+        ok(t("repo_good_shape", suffix="  (quick)" if quick else ""))
+        return 0
+
+    print_header(t("diagnostic", suffix=" quick" if quick else "", count=str(len(findings))))
+    print_blank()
+    for f in findings:
+        sev = f["severity"]
+        if sev in ("critical", "high"):
+            print_error_styled(f"  [{sev.upper()}] {f['message']}")
+        elif sev == "medium":
+            print_bracket(sev.upper(), f["message"])
+        else:
+            print_dim(f"  [{sev.upper()}] {f['message']}")
+        print_dim(f"     {t('audit_fix_label')}:    `{f['fix']}`")
+        print_dim(f"     {t('audit_ignore_label')}: {f['cost_of_ignore']}")
+        print_blank()
+
+    return 0 if not has_issues else 1