gitwise-cli 0.24.2__py3-none-any.whl

gitwise/diff.py

@@ -0,0 +1,309 @@
+"""Focused changed-file list for AI agents and humans."""
+
+from pathlib import Path
+
+from .git import require_root
+from .git import run as git_run
+from .i18n import t
+from .output import (
+    HAS_DELTA,
+    bat_pipe,
+    error,
+    info,
+    print_diffstat,
+    print_dim,
+    print_file_status,
+    print_header,
+    print_json,
+)
+from .utils.git_output import parse_name_status_entries
+from .utils.json_envelope import ok_envelope
+
+DiffValue = str | int | bool
+DiffFileEntry = dict[str, DiffValue]
+
+
+def _parse_diffstat_entries(lines: list[str]) -> list[DiffFileEntry]:
+    entries: list[DiffFileEntry] = []
+    for line in lines:
+        if "|" not in line:
+            continue
+        parts = line.split("|", 1)
+        if len(parts) != 2:
+            continue
+        path = parts[0].strip()
+        changes = parts[1].strip()
+        if not path:
+            continue
+        changed_count = 0
+        graph = ""
+        change_parts = changes.split(" ", 1)
+        if change_parts and change_parts[0].isdigit():
+            changed_count = int(change_parts[0])
+        if len(change_parts) == 2:
+            graph = change_parts[1].strip()
+        entry: DiffFileEntry = {
+            "path": path,
+            "changes": changes,
+            "lines_changed": changed_count,
+            "graph": graph,
+        }
+        entries.append(entry)
+    return entries
+
+
+def _parse_name_status_lines(lines: list[str]) -> dict[str, DiffFileEntry]:
+    entries: dict[str, DiffFileEntry] = {}
+    parsed = parse_name_status_entries("\n".join(lines))
+    for entry in parsed:
+        path = entry.get("path")
+        if not path:
+            continue
+        typed_entry: DiffFileEntry = dict(entry)
+        entries[path] = typed_entry
+    return entries
+
+
+def _diff_totals(files: list[DiffFileEntry]) -> DiffFileEntry:
+    insertions = 0
+    deletions = 0
+    lines_changed = 0
+    binary_files = 0
+    for item in files:
+        ins = item.get("insertions")
+        dels = item.get("deletions")
+        changed = item.get("lines_changed")
+        is_binary = item.get("is_binary")
+        if isinstance(ins, int):
+            insertions += ins
+        if isinstance(dels, int):
+            deletions += dels
+        if isinstance(changed, int):
+            lines_changed += changed
+        if is_binary is True:
+            binary_files += 1
+    return {
+        "insertions": insertions,
+        "deletions": deletions,
+        "lines_changed": lines_changed,
+        "binary_files": binary_files,
+    }
+
+
+def _name_status_details(cwd: Path, *, staged: bool) -> dict[str, DiffFileEntry]:
+    args = ["--no-pager", "diff", "--name-status"]
+    if staged:
+        args.append("--staged")
+    else:
+        args.append("HEAD")
+    r = git_run(args, cwd=cwd, check=False)
+    if r.returncode != 0:
+        return {}
+    return _parse_name_status_lines(r.stdout.splitlines())
+
+
+def _numstat_details(cwd: Path, *, staged: bool) -> dict[str, DiffFileEntry]:
+    args = ["--no-pager", "diff", "--numstat"]
+    if staged:
+        args.append("--staged")
+    else:
+        args.append("HEAD")
+    r = git_run(args, cwd=cwd, check=False)
+    if r.returncode != 0:
+        return {}
+
+    details: dict[str, DiffFileEntry] = {}
+    for line in r.stdout.splitlines():
+        parts = line.split("\t")
+        if len(parts) < 3:
+            continue
+        add_raw = parts[0].strip()
+        del_raw = parts[1].strip()
+        path = parts[2].strip()
+        if not path:
+            continue
+
+        if add_raw == "-" or del_raw == "-":
+            details[path] = {"path": path, "is_binary": True}
+            continue
+
+        if not (add_raw.isdigit() and del_raw.isdigit()):
+            continue
+
+        details[path] = {
+            "path": path,
+            "insertions": int(add_raw),
+            "deletions": int(del_raw),
+            "is_binary": False,
+        }
+    return details
+
+
+def _has_commits(cwd: Path) -> bool:
+    return git_run(["rev-parse", "HEAD"], cwd=cwd, check=False).returncode == 0
+
+
+def _diff_cmd(*, use_stat: bool, staged: bool, name_only: bool, full: bool) -> list[str]:
+    if full:
+        return ["--no-pager", "diff", "HEAD"]
+    if use_stat:
+        return ["--no-pager", "diff", "--stat", "HEAD"]
+    if staged:
+        return ["--no-pager", "diff", "--name-status", "--staged"]
+    if name_only:
+        return ["--no-pager", "diff", "--name-only", "HEAD"]
+    return ["--no-pager", "diff", "--name-status", "HEAD"]
+
+
+def _print_diff_human_full(*, diff_text: str) -> None:
+    if HAS_DELTA:
+        print_dim(t("using_delta"))
+    bat_pipe(diff_text, language="diff")
+
+
+def _merge_stat_files(
+    *,
+    files: list[DiffFileEntry],
+    status_details: dict[str, DiffFileEntry],
+    numstat_details: dict[str, DiffFileEntry],
+) -> list[DiffFileEntry]:
+    merged_files: list[DiffFileEntry] = []
+    for item in files:
+        path_value = item.get("path")
+        if not isinstance(path_value, str) or not path_value:
+            continue
+        merged: DiffFileEntry = dict(item)
+        if path_value in status_details:
+            for key, value in status_details[path_value].items():
+                merged[key] = value
+        if path_value in numstat_details:
+            for key, value in numstat_details[path_value].items():
+                merged[key] = value
+        merged_files.append(merged)
+    return merged_files
+
+
+def _render_stat_output(
+    *,
+    files: list[DiffFileEntry],
+    cwd: Path,
+    staged: bool,
+    as_json: bool,
+) -> int:
+    if not files:
+        if as_json:
+            print_json(ok_envelope(files=[], count=0))
+            return 0
+        info(t("no_uncommitted_changes"))
+        return 0
+
+    status_details = _name_status_details(cwd, staged=staged)
+    numstat_details = _numstat_details(cwd, staged=staged)
+    merged_files = _merge_stat_files(
+        files=files,
+        status_details=status_details,
+        numstat_details=numstat_details,
+    )
+    if as_json:
+        print_json(
+            ok_envelope(
+                files=merged_files,
+                count=len(merged_files),
+                totals=_diff_totals(merged_files),
+            )
+        )
+        return 0
+
+    styled_files = [
+        {
+            "path": str(file_item.get("path", "")),
+            "changes": str(file_item.get("changes", "")),
+            "status": str(file_item.get("code", file_item.get("status", "M"))),
+        }
+        for file_item in merged_files
+        if str(file_item.get("path", ""))
+    ]
+    print_diffstat(t("changed_files", count=str(len(styled_files))), styled_files)
+    return 0
+
+
+def _render_non_stat_output(
+    *,
+    lines: list[str],
+    staged: bool,
+    name_only: bool,
+    as_json: bool,
+) -> int:
+    if not lines:
+        if as_json:
+            print_json(ok_envelope(files=[], count=0))
+            return 0
+        if staged:
+            info(t("nothing_staged"))
+        else:
+            info(t("tip_staged"))
+        return 0
+
+    if name_only:
+        files = [{"path": line.strip()} for line in lines if line.strip()]
+    else:
+        files = []
+        for line in lines:
+            parts = line.split("\t", 1)
+            if len(parts) == 2:
+                files.append({"status": parts[0].strip(), "path": parts[1].strip()})
+
+    if as_json:
+        print_json(ok_envelope(files=files, count=len(files)))
+        return 0
+
+    print_header(t("changed_files", count=str(len(files))))
+    for file_item in files:
+        print_file_status(file_item["status"], file_item["path"])
+    return 0
+
+
+def run_diff(
+    *,
+    staged: bool = False,
+    stat: bool = False,
+    name_only: bool = False,
+    full: bool = False,
+    as_json: bool = False,
+) -> int:
+    root, err = require_root()
+    if err:
+        return err
+    if root is None:
+        return 1
+    cwd = root
+
+    if not staged and not _has_commits(cwd):
+        if as_json:
+            print_json(ok_envelope(files=[], count=0, note=t("no_commits_yet")))
+            return 0
+        info(t("no_commits_yet"))
+        return 0
+
+    use_stat = stat or (not staged and not name_only and not full)
+    cmd = _diff_cmd(use_stat=use_stat, staged=staged, name_only=name_only, full=full)
+    result = git_run(cmd, cwd=cwd, check=False)
+    if result.returncode != 0:
+        error(t("git_diff_failed", error=result.stderr.strip()))
+        return 1
+
+    if full:
+        if as_json:
+            print_json(ok_envelope(diff=result.stdout))
+        else:
+            _print_diff_human_full(diff_text=result.stdout)
+        return 0
+
+    lines = [line for line in result.stdout.splitlines() if line.strip()]
+    if use_stat:
+        files = _parse_diffstat_entries(lines)
+        return _render_stat_output(files=files, cwd=cwd, staged=staged, as_json=as_json)
+
+    return _render_non_stat_output(
+        lines=lines, staged=staged, name_only=name_only, as_json=as_json
+    )

gitwise/doctor.py

@@ -0,0 +1,116 @@
+"""Detects git version, Python version, platform, and optional deps."""
+
+import platform
+import shutil
+import sys
+
+from . import __version__
+from .git import gpg_status
+from .git import version as git_version
+from .i18n import t
+from .output import (
+    print_blank,
+    print_dim,
+    print_header,
+    print_json,
+    print_kv,
+    print_status_line,
+    warn,
+)
+
+MIN_GIT = (2, 29, 0)
+
+_OPTIONAL_TOOLS = ["bat", "delta", "rg", "eza", "git-sizer", "watchman"]
+
+_TOOL_INFO: dict[str, tuple[str, str]] = {
+    "bat": ("tool_bat_desc", "brew install bat"),
+    "delta": ("tool_delta_desc", "brew install git-delta"),
+    "rg": ("tool_rg_desc", "brew install ripgrep"),
+    "eza": ("tool_eza_desc", "brew install eza"),
+    "git-sizer": ("tool_git_sizer_desc", "brew install git-sizer"),
+    "watchman": ("tool_watchman_desc", "brew install watchman"),
+}
+
+
+def run_doctor(*, as_json: bool = False) -> int:
+    git_ver = git_version()
+    git_ok = git_ver >= MIN_GIT
+
+    python_ver = sys.version_info[:3]
+    python_ok = python_ver >= (3, 9)
+
+    platform_name = platform.system()
+    fsmonitor_supported = platform_name in ("Darwin", "Windows")
+
+    optional = {tool: bool(shutil.which(tool)) for tool in _OPTIONAL_TOOLS}
+    gpg = gpg_status()
+
+    result = {
+        "v": 2,
+        "gitwise_version": __version__,
+        "git_version": ".".join(str(n) for n in git_ver),
+        "git_version_ok": git_ok,
+        "git_min_required": ".".join(str(n) for n in MIN_GIT),
+        "python_version": ".".join(str(n) for n in python_ver),
+        "python_version_ok": python_ok,
+        "platform": platform_name,
+        "fsmonitor_supported": fsmonitor_supported,
+        "optional_tools": optional,
+        "gpg": gpg,
+        "ok": git_ok and python_ok,
+    }
+
+    if as_json:
+        print_json(result)
+        return 0 if result["ok"] else 1
+
+    print_header(f"gitwise {__version__}")
+    print_blank()
+
+    git_str = ".".join(str(n) for n in git_ver)
+    min_str = ".".join(str(n) for n in MIN_GIT)
+    if git_ok:
+        print_status_line("✓", t("doctor_git_label"), git_str, ok_flag=True)
+    else:
+        print_status_line("✗", t("doctor_git_label"), git_str, ok_flag=False)
+        warn(t("git_too_old", ver=git_str, min=min_str))
+
+    py_str = ".".join(str(n) for n in python_ver)
+    if python_ok:
+        print_status_line("✓", t("doctor_python_label"), py_str, ok_flag=True)
+    else:
+        print_status_line("✗", t("doctor_python_label"), py_str, ok_flag=False)
+        warn(t("python_too_old", ver=py_str))
+
+    print_status_line("✓", t("platform_label", name=platform_name), "", ok_flag=True)
+
+    if not fsmonitor_supported:
+        warn(t("fsmonitor_not_supported"))
+
+    print_blank()
+    print_header(t("optional_tools"))
+    for tool, found in optional.items():
+        if found:
+            print_status_line("✓", tool, "", ok_flag=True)
+        else:
+            desc_key, install = _TOOL_INFO.get(tool, ("", f"brew install {tool}"))
+            desc = t(desc_key) if desc_key else ""
+            print_status_line("–", tool, "", ok_flag=False)
+            print_kv(t("doctor_purpose_label"), desc)
+            print_kv(t("doctor_install_label"), install)
+
+    print_blank()
+    print_header(t("gpg_title"))
+    if gpg["ready"]:
+        print_status_line("✓", t("gpg_ready_msg"), "", ok_flag=True)
+    elif not gpg["gpg_binary"]:
+        print_status_line("✗", t("gpg_not_installed"), "", ok_flag=False)
+        print_dim(t("gpg_install_instruction"))
+    elif not gpg["gpgsign_enabled"]:
+        print_status_line("–", t("gpg_not_enabled"), "", ok_flag=False)
+        print_dim(t("gpg_enable_instruction"))
+    elif not gpg["signing_key_set"]:
+        print_status_line("✗", t("gpg_no_signing_key"), "", ok_flag=False)
+        print_dim(t("gpg_key_instruction"))
+
+    return 0 if result["ok"] else 1

gitwise/git.py

@@ -0,0 +1,254 @@
+"""Thin wrappers over subprocess for git operations."""
+
+import functools
+import os
+import re
+import subprocess
+from pathlib import Path
+
+_NESTED_QUANTIFIER_RE = re.compile(
+    r"(\([^)]*[+*][^)]*\)[+*{])"
+    r"|(\[[^\]]*[+*][^\]]*\][+*{])"
+    r"|(\(.+\|.+\)[+*{])"
+)
+
+_GREP_MAX_LEN = 200
+
+
+_GIT_ENV = {**os.environ, "LC_ALL": "C", "GIT_TERMINAL_PROMPT": "0"}
+
+_DEFAULT_TIMEOUT = 120
+
+_NETWORK_TIMEOUT = 60
+
+_CMD_TIMEOUTS: dict[str, int] = {
+    "diff-tree": 30,
+    "diff": 30,
+    "log": 30,
+    "status": 10,
+    "branch": 10,
+    "stash": 10,
+    "ls-files": 10,
+    "rev-list": 30,
+    "shortlog": 30,
+    "grep": 30,
+    "for-each-ref": 10,
+    "rev-parse": 10,
+    "config": 5,
+    "tag": 10,
+    "commit": 30,
+    "fetch": _NETWORK_TIMEOUT,
+    "push": _NETWORK_TIMEOUT,
+    "pull": _NETWORK_TIMEOUT,
+    "clone": _NETWORK_TIMEOUT,
+}
+
+
+def _get_timeout(cmd: str | None = None) -> int:
+    val = os.environ.get("GITWISE_GIT_TIMEOUT", "")
+    if val.isdigit():
+        return int(val)
+    if cmd and cmd in _CMD_TIMEOUTS:
+        return _CMD_TIMEOUTS[cmd]
+    return _DEFAULT_TIMEOUT
+
+
+def run(
+    args: list[str],
+    cwd: Path | None = None,
+    check: bool = False,
+    timeout: int | None = None,
+) -> subprocess.CompletedProcess[str]:
+    from .output import debug
+
+    cmd_name = args[0] if args else None
+    actual_timeout = timeout if timeout is not None else _get_timeout(cmd_name)
+    debug(f"git {' '.join(args)}")
+    return subprocess.run(
+        ["git"] + args,
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        cwd=cwd,
+        check=check,
+        env=_GIT_ENV,
+        timeout=actual_timeout,
+    )
+
+
+def config(key: str, cwd: Path | None = None) -> str | None:
+    result = run(["config", "--get", key], cwd=cwd, check=False)
+    return result.stdout.strip() if result.returncode == 0 else None
+
+
+def config_all(key: str, cwd: Path | None = None) -> list[str]:
+    result = run(["config", "--get-all", key], cwd=cwd, check=False)
+    if result.returncode != 0:
+        return []
+    return [line.strip() for line in result.stdout.splitlines() if line.strip()]
+
+
+def is_repo(path: Path | None = None) -> bool:
+    result = run(["rev-parse", "--git-dir"], cwd=path, check=False)
+    return result.returncode == 0
+
+
+def repo_root(path: Path | None = None) -> Path | None:
+    result = run(["rev-parse", "--show-toplevel"], cwd=path, check=False)
+    return Path(result.stdout.strip()) if result.returncode == 0 else None
+
+
+def git_dir(cwd: Path | None = None) -> Path | None:
+    r = run(["rev-parse", "--absolute-git-dir"], cwd=cwd, check=False)
+    return Path(r.stdout.strip()) if r.returncode == 0 else None
+
+
+def current_branch(cwd: Path | None = None) -> str | None:
+    r = run(["branch", "--show-current"], cwd=cwd, check=False)
+    val = r.stdout.strip()
+    return val if (r.returncode == 0 and val) else None
+
+
+def stale_branches(cwd: Path | None = None) -> list[str]:
+    """Returns branch names whose upstream is [gone]."""
+    r = run(
+        ["for-each-ref", "--format=%(refname:short)\t%(upstream:track)", "refs/heads/"],
+        cwd=cwd,
+        check=False,
+    )
+    if r.returncode != 0:
+        return []
+    result = []
+    for line in r.stdout.splitlines():
+        parts = line.split("\t", 1)
+        if len(parts) == 2 and "[gone]" in parts[1]:
+            result.append(parts[0])
+    return result
+
+
+def worktree_branches(cwd: Path | None = None) -> set[str]:
+    """Returns set of branch names currently checked out in any worktree."""
+    r = run(["worktree", "list", "--porcelain"], cwd=cwd, check=False)
+    if r.returncode != 0:
+        return set()
+    return {
+        line.removeprefix("branch refs/heads/")
+        for line in r.stdout.splitlines()
+        if line.startswith("branch refs/heads/")
+    }
+
+
+def gpg_status(cwd: Path | None = None) -> dict[str, bool]:
+    """Returns GPG signing readiness for cwd (falls back to global git config)."""
+    import shutil
+
+    gpg_bin = bool(shutil.which("gpg") or shutil.which("gpg2"))
+    gpgsign = config("commit.gpgsign", cwd=cwd)
+    signing_key = config("user.signingkey", cwd=cwd)
+    return {
+        "gpg_binary": gpg_bin,
+        "gpgsign_enabled": gpgsign == "true",
+        "signing_key_set": bool(signing_key),
+        "ready": gpg_bin and gpgsign == "true" and bool(signing_key),
+    }
+
+
+@functools.lru_cache(maxsize=1)
+def version() -> tuple[int, int, int]:
+    result = run(["--version"], check=False)
+    # "git version 2.45.0" -> (2, 45, 0)
+    parts = result.stdout.strip().split()
+    if len(parts) >= 3:
+        nums = parts[2].split(".")
+        try:
+            return (
+                int(nums[0]),
+                int(nums[1]) if len(nums) > 1 else 0,
+                int(nums[2]) if len(nums) > 2 else 0,
+            )
+        except (ValueError, IndexError):
+            from .output import debug as _debug
+
+            _debug(f"git version parse failed: {result.stdout.strip()!r}")
+    return (0, 0, 0)
+
+
+def supports_config_hooks(cwd: Path | None = None) -> bool:
+    if version() < (2, 36, 0):
+        return False
+    result = run(["hook", "run", "--ignore-missing", "pre-commit"], cwd=cwd, check=False)
+    return result.returncode == 0
+
+
+def validate_ref(ref: str) -> bool:
+    return bool(ref) and not ref.startswith("-")
+
+
+def validate_branch_name(name: str) -> bool:
+    if not name or name.startswith("-"):
+        return False
+    result = run(["check-ref-format", f"refs/heads/{name}"], check=False)
+    return result.returncode == 0
+
+
+def validate_grep_pattern(pattern: str) -> bool:
+    if len(pattern) > _GREP_MAX_LEN:
+        return False
+    if _NESTED_QUANTIFIER_RE.search(pattern):
+        return False
+    try:
+        re.compile(pattern)
+    except re.error:
+        return False
+    return True
+
+
+def validate_author_pattern(pattern: str) -> bool:
+    if len(pattern) > _GREP_MAX_LEN:
+        return False
+    if "\n" in pattern or "\r" in pattern or "\x00" in pattern:
+        return False
+    if _NESTED_QUANTIFIER_RE.search(pattern):
+        return False
+    try:
+        re.compile(pattern)
+    except re.error:
+        return False
+    return True
+
+
+PROTECTED_BRANCHES: frozenset[str] = frozenset(
+    {"main", "master", "develop", "dev", "trunk", "release"}
+)
+
+
+def require_root(path: Path | None = None) -> tuple[Path, None] | tuple[None, int]:
+    """Validate git repo and return (root, None) or (None, exit_code)."""
+    from .i18n import t
+    from .output import error
+
+    root = repo_root(path)
+    if root is None:
+        error(t("not_a_git_repo"))
+        return None, 1
+    return root, None
+
+
+def has_remote(cwd: Path | None = None) -> bool:
+    r = run(["remote"], cwd=cwd, check=False)
+    return r.returncode == 0 and bool(r.stdout.strip())
+
+
+def has_upstream(cwd: Path | None = None) -> bool:
+    r = run(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], cwd=cwd, check=False)
+    return r.returncode == 0 and bool(r.stdout.strip())
+
+
+def has_commit_graph(cwd: Path | None = None) -> bool:
+    gd = git_dir(cwd)
+    if gd is None:
+        return False
+    return (gd / "objects" / "info" / "commit-graph").exists() or (
+        gd / "objects" / "info" / "commit-graphs" / "commit-graph-chain"
+    ).exists()