gitwise-cli 0.24.2__py3-none-any.whl

gitwise/status.py

@@ -0,0 +1,93 @@
+"""gitwise status — enhanced git status for humans and AI agents."""
+
+from .git import current_branch, has_upstream, require_root
+from .git import run as git_run
+from .i18n import t
+from .output import (
+    info,
+    ok,
+    print_blank,
+    print_bracket,
+    print_file_status,
+    print_header,
+    print_json,
+)
+from .utils.parsing import parse_two_ints
+
+
+def run_status(*, as_json: bool = False) -> int:
+    root, err = require_root()
+    if err:
+        return err
+    if root is None:
+        return 1
+
+    branch = current_branch(root) or t("detached_head")
+
+    status_r = git_run(["status", "--porcelain"], cwd=root, check=False)
+    status_lines = status_r.stdout.splitlines() if status_r.returncode == 0 else []
+
+    staged = [ln for ln in status_lines if ln and ln[0] not in (" ", "?")]
+    unstaged = [ln for ln in status_lines if ln and ln[1] not in (" ", "?")]
+    untracked = [ln for ln in status_lines if ln and ln.startswith("??")]
+
+    ahead = behind = 0
+    if has_upstream(root):
+        ab_r = git_run(
+            ["rev-list", "--left-right", "--count", "HEAD...@{u}"],
+            cwd=root,
+            check=False,
+        )
+        if ab_r.returncode == 0:
+            parsed = parse_two_ints(ab_r.stdout)
+            if parsed is not None:
+                ahead, behind = parsed
+
+    if as_json:
+        print_json(
+            {
+                "v": 2,
+                "ok": True,
+                "branch": branch,
+                "has_upstream": has_upstream(root),
+                "ahead": ahead,
+                "behind": behind,
+                "staged": len(staged),
+                "unstaged": len(unstaged),
+                "untracked": len(untracked),
+                "files": [ln[3:] for ln in status_lines],
+            }
+        )
+        return 0
+
+    print_header(t("branch_label", branch=branch))
+    if ahead or behind:
+        print_bracket(t("status_ahead_label"), str(ahead))
+        print_bracket(t("status_behind_label"), str(behind))
+
+    if not status_lines:
+        print_blank()
+        ok(t("working_tree_clean"))
+        return 0
+
+    if staged:
+        print_blank()
+        print_header(f"{t('status_staged_label')} ({len(staged)}):")
+        for line in staged:
+            print_file_status(line[:2], line[3:])
+
+    if unstaged:
+        print_blank()
+        print_header(f"{t('status_unstaged_label')} ({len(unstaged)}):")
+        for line in unstaged:
+            print_file_status(line[:2], line[3:])
+
+    if untracked:
+        print_blank()
+        print_header(f"{t('status_untracked_label')} ({len(untracked)}):")
+        for line in untracked[:10]:
+            print_file_status("??", line[3:])
+        if len(untracked) > 10:
+            info(f"    {t('status_more_files', count=str(len(untracked) - 10))}")
+
+    return 0

gitwise/suggest.py

@@ -0,0 +1,148 @@
+"""gitwise suggest — heuristic commit message from staged diff."""
+
+import re
+
+from .git import require_root
+from .git import run as git_run
+from .i18n import t
+from .output import error, print_bracket, print_file_status, print_header, print_json
+from .utils.json_envelope import error_envelope, ok_envelope
+from .utils.parsing import stripped_non_empty_lines
+
+_TYPE_MAP: list[tuple[str, str]] = [
+    (r"/test", "test"),
+    (r"test_", "test"),
+    (r"_test\.", "test"),
+    (r"README", "docs"),
+    (r"CHANGELOG", "docs"),
+    (r"\.md$", "docs"),
+    (r"\.txt$", "docs"),
+    (r"Dockerfile", "build"),
+    (r"docker-compose", "build"),
+    (r"\.ya?ml$", "ci"),
+    (r"\.toml$", "build"),
+    (r"\.cfg$", "build"),
+    (r"\.json$", "chore"),
+    (r"\.lock$", "chore"),
+]
+
+
+def _infer_type(files: list[str]) -> str:
+    for pattern, commit_type in _TYPE_MAP:
+        for f in files:
+            if re.search(pattern, f):
+                return commit_type
+    return "feat"
+
+
+def _infer_scope(files: list[str]) -> str | None:
+    dirs: set[str] = set()
+    for f in files:
+        parts = f.split("/")
+        if len(parts) > 1:
+            dirs.add(parts[0])
+    if len(dirs) == 1:
+        return dirs.pop()
+    return None
+
+
+def _build_message(staged_files: list[str], additions: int, deletions: int) -> str:
+    commit_type = _infer_type(staged_files)
+    scope = _infer_scope(staged_files)
+    scope_str = f"({scope})" if scope else ""
+    if len(staged_files) == 1:
+        filename = staged_files[0].rsplit("/", 1)[-1]
+        return f"{commit_type}{scope_str}: {t('suggest_update_file', filename=filename)}"
+    return f"{commit_type}{scope_str}: {t('suggest_update_files', count=str(len(staged_files)))}"
+
+
+def _staged_with_status(root) -> list[tuple[str, str]]:
+    r = git_run(["diff", "--cached", "--name-status"], cwd=root, check=False)
+    if r.returncode != 0:
+        return []
+    pairs: list[tuple[str, str]] = []
+    for line in r.stdout.splitlines():
+        parts = line.split("\t")
+        if len(parts) < 2:
+            continue
+        status = parts[0][:1].upper()
+        path = parts[-1].strip()
+        if path:
+            pairs.append((status, path))
+    return pairs
+
+
+def _collect_staged_files(root) -> tuple[list[str], dict[str, str]]:
+    r = git_run(["diff", "--cached", "--name-only"], cwd=root, check=False)
+    if r.returncode != 0:
+        raise RuntimeError("staged_diff_failed")
+    staged_files = stripped_non_empty_lines(r.stdout)
+    staged_pairs = _staged_with_status(root)
+    staged_map = {path: status for status, path in staged_pairs}
+    return staged_files, staged_map
+
+
+def _numstat_totals(root) -> tuple[int, int]:
+    stat = git_run(["diff", "--cached", "--numstat"], cwd=root, check=False)
+    additions = deletions = 0
+    if stat.returncode != 0:
+        return additions, deletions
+    for line in stat.stdout.splitlines():
+        parts = line.split()
+        if len(parts) < 2:
+            continue
+        added = parts[0]
+        removed = parts[1]
+        if added != "-" and added.isdigit():
+            additions += int(added)
+        if removed != "-" and removed.isdigit():
+            deletions += int(removed)
+    return additions, deletions
+
+
+def _print_suggest_human(
+    message: str, staged_files: list[str], staged_map: dict[str, str]
+) -> None:
+    print_header(t("suggest_message", message=message))
+    print_bracket(t("suggest_type", type=_infer_type(staged_files)))
+    for file_path in staged_files:
+        print_file_status(staged_map.get(file_path, "M"), file_path)
+
+
+def run_suggest(*, as_json: bool = False) -> int:
+    root, err = require_root()
+    if err:
+        return err
+    if root is None:
+        return 1
+
+    try:
+        staged_files, staged_map = _collect_staged_files(root)
+    except RuntimeError:
+        error(t("suggest_diff_failed"))
+        return 1
+
+    if not staged_files:
+        if as_json:
+            print_json(error_envelope(error=t("suggest_no_staged")))
+            return 1
+        error(t("suggest_no_staged"))
+        return 1
+
+    additions, deletions = _numstat_totals(root)
+
+    message = _build_message(staged_files, additions, deletions)
+
+    if as_json:
+        print_json(
+            ok_envelope(
+                message=message,
+                files=staged_files,
+                additions=additions,
+                deletions=deletions,
+            )
+        )
+        return 0
+
+    _print_suggest_human(message, staged_files, staged_map)
+    return 0

gitwise/summarize.py

@@ -0,0 +1,202 @@
+"""Compact git status + log for Claude Code context reduction."""
+
+import subprocess
+
+from ._runtime_config import get_runtime_config
+from .git import require_root
+from .git import run as git_run
+from .i18n import t
+from .output import (
+    bat_pipe,
+    debug,
+    ok,
+    print_blank,
+    print_bullet,
+    print_commit_line,
+    print_file_status,
+    print_header,
+    print_json,
+    warn,
+)
+
+_MAX_STATUS_LINES = 12
+
+
+def _status_code(index: str, worktree: str) -> str:
+    if index == "?" and worktree == "?":
+        return "??"
+    if worktree not in {" ", "?"}:
+        return worktree
+    if index not in {" ", "?"}:
+        return index
+    return "--"
+
+
+def _parse_status_entries(status_lines: list[str]) -> list[dict[str, str]]:
+    entries: list[dict[str, str]] = []
+    for line in status_lines:
+        if len(line) < 4:
+            continue
+        index = line[0]
+        worktree = line[1]
+        path_part = line[3:].strip()
+        if not path_part:
+            continue
+        entry: dict[str, str] = {
+            "index": index,
+            "worktree": worktree,
+            "status": _status_code(index, worktree),
+        }
+        if " -> " in path_part:
+            old_path, new_path = path_part.split(" -> ", 1)
+            entry["old_path"] = old_path
+            entry["path"] = new_path
+        else:
+            entry["path"] = path_part
+        entries.append(entry)
+    return entries
+
+
+def _parse_log_entries(log_lines: list[str]) -> list[dict[str, str]]:
+    entries: list[dict[str, str]] = []
+    for line in log_lines:
+        parts = line.split(" ", 1)
+        if len(parts) != 2:
+            continue
+        entries.append({"short_hash": parts[0], "subject": parts[1]})
+    return entries
+
+
+def _parse_changed_entries(changed_files: list[str]) -> list[dict[str, str]]:
+    entries: list[dict[str, str]] = []
+    for line in changed_files:
+        parts = line.split("\t")
+        if len(parts) < 2:
+            continue
+        status = parts[0].strip()
+        code = status[:1].upper() if status else ""
+        entry: dict[str, str] = {"status": status}
+        if code and code != status:
+            entry["code"] = code
+        if code in {"R", "C"} and len(parts) >= 3:
+            entry["old_path"] = parts[1].strip()
+            entry["path"] = parts[2].strip()
+        else:
+            entry["path"] = parts[-1].strip()
+        if len(status) > 1 and status[1:].isdigit():
+            entry["score"] = status[1:]
+        if entry["path"]:
+            entries.append(entry)
+    return entries
+
+
+def run_summarize(*, as_json: bool = False, diff: bool = False, max_commits: int = 10) -> int:
+    root, err = require_root()
+    if err:
+        return err
+    if root is None:
+        return 1
+    cwd = root
+
+    branch_r = git_run(["branch", "--show-current"], cwd=cwd, check=False)
+    branch = branch_r.stdout.strip() if branch_r.returncode == 0 else "detached-HEAD"
+
+    status_r = git_run(["status", "--short"], cwd=cwd, check=False)
+    status_lines = status_r.stdout.splitlines() if status_r.returncode == 0 else []
+
+    log_r = git_run(
+        ["--no-pager", "log", "--oneline", f"-n{max_commits}"],
+        cwd=cwd,
+        check=False,
+    )
+    log_lines = log_r.stdout.splitlines() if log_r.returncode == 0 else []
+
+    shortstat_r = git_run(["--no-pager", "diff", "--shortstat"], cwd=cwd, check=False)
+    shortstat = shortstat_r.stdout.strip() if shortstat_r.returncode == 0 else ""
+
+    changed_r = git_run(["--no-pager", "diff", "--name-status", "HEAD"], cwd=cwd, check=False)
+    changed_files = changed_r.stdout.splitlines() if changed_r.returncode == 0 else []
+
+    status_entries = _parse_status_entries(status_lines)
+    status_map = {entry["path"]: entry["status"] for entry in status_entries}
+    log_entries = _parse_log_entries(log_lines)
+    log_map = {entry["short_hash"]: entry["subject"] for entry in log_entries}
+    changed_entries = _parse_changed_entries(changed_files)
+
+    if as_json:
+        import json
+
+        result: dict = {
+            "v": 3,
+            "ok": True,
+            "branch": branch,
+            "status": status_map,
+            "status_count": len(status_entries),
+            "log": log_map,
+            "log_count": len(log_entries),
+            "shortstat": shortstat,
+            "changed_files": changed_entries,
+            "changed_count": len(changed_entries),
+        }
+        if diff:
+            diff_r = git_run(["--no-pager", "diff"], cwd=cwd, check=False)
+            result["diff"] = diff_r.stdout if diff_r.returncode == 0 else ""
+        print_json(result)
+        output_size = len(json.dumps(result))
+        if output_size > 8192:
+            warn(t("output_exceeds_8kb", size=str(output_size)))
+        return 0
+
+    print_header(t("branch_label", branch=branch))
+    print_blank()
+
+    if status_lines:
+        print_header(t("modified_files_status", count=str(len(status_lines))))
+        for line in status_lines[:_MAX_STATUS_LINES]:
+            print_file_status(line[:2], line[3:])
+        if len(status_lines) > _MAX_STATUS_LINES:
+            print_bullet(
+                t("status_more_files", count=str(len(status_lines) - _MAX_STATUS_LINES)),
+                icon="+",
+                accent=False,
+            )
+        print_blank()
+    else:
+        ok(t("working_tree_clean"))
+        print_blank()
+
+    if log_lines:
+        print_header(t("last_commits", count=str(len(log_lines))))
+        for line in log_lines:
+            print_commit_line(line)
+        print_blank()
+    else:
+        print_bullet(t("no_commits_yet"), icon="-", accent=False)
+        print_blank()
+
+    if shortstat:
+        print_header(t("diff_prefix", stat=shortstat))
+
+    if diff:
+        diff_r = git_run(["--no-pager", "diff"], cwd=cwd, check=False)
+        if diff_r.stdout:
+            cfg = get_runtime_config()
+            if cfg.has_delta and cfg.is_tty:
+                debug(t("using_delta"))
+                try:
+                    subprocess.run(
+                        ["delta"],
+                        input=diff_r.stdout,
+                        text=True,
+                        timeout=120,
+                        check=False,
+                    )
+                except subprocess.TimeoutExpired:
+                    bat_pipe(diff_r.stdout, language="diff")
+                except (FileNotFoundError, OSError):
+                    bat_pipe(diff_r.stdout, language="diff")
+            else:
+                stat_r = git_run(["--no-pager", "diff", "--stat"], cwd=cwd, check=False)
+                bat_pipe(stat_r.stdout, language="diff")
+
+    return 0

gitwise/sync.py

@@ -0,0 +1,257 @@
+"""gitwise sync — remote fetch, safe pull/push, ahead/behind reporting."""
+
+from pathlib import Path
+
+from .git import PROTECTED_BRANCHES, current_branch, require_root
+from .git import run as git_run
+from .i18n import t
+from .output import (
+    debug,
+    error,
+    print_bracket,
+    print_dim,
+    print_header,
+    print_json,
+    status,
+)
+from .utils.json_envelope import error_envelope, ok_envelope
+from .utils.parsing import parse_two_ints, stripped_non_empty_lines
+
+
+def _ahead_behind(cwd: Path) -> dict[str, int]:
+    branch = current_branch(cwd=cwd)
+    if not branch:
+        return {"ahead": 0, "behind": 0}
+    r = git_run(
+        ["rev-list", "--left-right", "--count", branch + "@{u}...HEAD"], cwd=cwd, check=False
+    )
+    if r.returncode != 0:
+        debug(f"ahead_behind failed: {r.stderr.strip()}")
+        return {"ahead": 0, "behind": 0}
+    parsed = parse_two_ints(r.stdout)
+    if parsed is not None:
+        behind, ahead = parsed
+        return {"behind": behind, "ahead": ahead}
+    debug(f"ahead_behind parse failed: {r.stdout.strip()!r}")
+    return {"ahead": 0, "behind": 0}
+
+
+def _unpushed_commits(cwd) -> list[str]:
+    branch = current_branch(cwd=cwd)
+    if not branch:
+        return []
+    r = git_run(["log", "--oneline", branch + "@{u}..HEAD"], cwd=cwd, check=False)
+    if r.returncode != 0:
+        debug(f"unpushed_commits failed: {r.stderr.strip()}")
+        return []
+    return stripped_non_empty_lines(r.stdout)
+
+
+def _sync_dry_run_payload(
+    *,
+    branch: str,
+    pull: bool,
+    push: bool,
+    remote: str | None,
+    root: Path,
+) -> dict[str, object]:
+    ab = _ahead_behind(root)
+    unpushed = _unpushed_commits(root)
+    return {
+        "branch": branch,
+        "ahead": ab["ahead"],
+        "behind": ab["behind"],
+        "unpushed": unpushed,
+        "actions": _planned_actions(pull, push, ab, unpushed, remote),
+        "dry_run": True,
+    }
+
+
+def _print_sync_dry_run_human(*, pull: bool, push: bool, root: Path, remote: str | None) -> None:
+    ab = _ahead_behind(root)
+    unpushed = _unpushed_commits(root)
+    print_header(t("sync_dry_run_title"))
+    for action in _planned_actions(pull, push, ab, unpushed, remote):
+        print_bracket(action)
+    print_dim(t("dry_run_no_exec"))
+
+
+def _sync_fetch(*, root: Path, remote: str | None, as_json: bool) -> int:
+    with status(t("status_sync_fetch")):
+        result = git_run(
+            ["fetch", "--prune"] + ([remote] if remote else ["--all"]), cwd=root, check=False
+        )
+    if result.returncode == 0:
+        return 0
+    if as_json:
+        print_json(
+            error_envelope(
+                error=t("sync_fetch_failed", error=result.stderr.strip()),
+                code="sync_fetch_failed",
+                hint=t("sync_hint"),
+            )
+        )
+    else:
+        error(t("sync_fetch_failed", error=result.stderr.strip()))
+    return 1
+
+
+_SYNC_PULL_DIVERGED_COMMANDS = (
+    "gitwise sync --dry-run --json",
+    "git pull --rebase",
+    "git pull --no-rebase",
+    "gitwise sync --push",
+)
+
+
+def _sync_pull(*, root: Path, as_json: bool) -> int:
+    with status(t("status_sync_pull")):
+        result = git_run(["pull", "--ff-only"], cwd=root, check=False)
+    if result.returncode == 0:
+        return 0
+    hint = t("sync_pull_diverged_hint")
+    if as_json:
+        print_json(
+            error_envelope(
+                error=t("sync_pull_diverged"),
+                code="sync_pull_diverged",
+                hint=hint,
+                suggested_commands=list(_SYNC_PULL_DIVERGED_COMMANDS),
+            )
+        )
+    else:
+        error(t("sync_pull_diverged"), hint=hint)
+    return 1
+
+
+def _sync_push(*, root: Path, branch: str, as_json: bool) -> int:
+    if branch in PROTECTED_BRANCHES:
+        if as_json:
+            print_json(
+                error_envelope(
+                    error=t("sync_push_protected", branch=branch),
+                    code="sync_push_protected",
+                    hint=t("sync_push_protected_hint"),
+                )
+            )
+        else:
+            error(t("sync_push_protected", branch=branch))
+        return 1
+    with status(t("status_sync_push")):
+        result = git_run(["push"], cwd=root, check=False)
+    if result.returncode == 0:
+        return 0
+    if as_json:
+        print_json(
+            error_envelope(
+                error=t("sync_push_failed", error=result.stderr.strip()),
+                code="sync_push_failed",
+                hint=t("sync_hint"),
+            )
+        )
+    else:
+        error(t("sync_push_failed", error=result.stderr.strip()))
+    return 1
+
+
+def _print_sync_complete_human(*, branch: str, ahead: int, behind: int) -> None:
+    print_header(t("sync_complete_title"))
+    print_bracket(branch, t("sync_status", ahead=str(ahead), behind=str(behind)))
+
+
+def _sync_final_payload(*, branch: str, root: Path) -> dict[str, object]:
+    ab = _ahead_behind(root)
+    return {
+        "branch": branch,
+        "ahead": ab["ahead"],
+        "behind": ab["behind"],
+        "unpushed": _unpushed_commits(root),
+    }
+
+
+def _report_sync_final(*, as_json: bool, branch: str, root: Path) -> int:
+    payload = _sync_final_payload(branch=branch, root=root)
+    if as_json:
+        print_json(ok_envelope(payload=payload))
+        return 0
+    ahead = payload["ahead"]
+    behind = payload["behind"]
+    _print_sync_complete_human(
+        branch=branch,
+        ahead=ahead if isinstance(ahead, int) else 0,
+        behind=behind if isinstance(behind, int) else 0,
+    )
+    return 0
+
+
+def _run_sync_dry_run(
+    *, as_json: bool, branch: str, pull: bool, push: bool, remote: str | None, root: Path
+) -> int:
+    if as_json:
+        print_json(
+            ok_envelope(
+                payload=_sync_dry_run_payload(
+                    branch=branch, pull=pull, push=push, remote=remote, root=root
+                )
+            )
+        )
+        return 0
+    _print_sync_dry_run_human(pull=pull, push=push, root=root, remote=remote)
+    return 0
+
+
+def run_sync(
+    *,
+    pull: bool = False,
+    push: bool = False,
+    remote: str | None = None,
+    dry_run: bool = False,
+    as_json: bool = False,
+) -> int:
+    root, err = require_root()
+    if err:
+        return err
+    if root is None:
+        return 1
+
+    branch = current_branch(cwd=root) or ""
+
+    if dry_run:
+        return _run_sync_dry_run(
+            as_json=as_json,
+            branch=branch,
+            pull=pull,
+            push=push,
+            remote=remote,
+            root=root,
+        )
+
+    fetch_rc = _sync_fetch(root=root, remote=remote, as_json=as_json)
+    if fetch_rc != 0:
+        return fetch_rc
+
+    if pull:
+        pull_rc = _sync_pull(root=root, as_json=as_json)
+        if pull_rc != 0:
+            return pull_rc
+
+    if push:
+        push_rc = _sync_push(root=root, branch=branch, as_json=as_json)
+        if push_rc != 0:
+            return push_rc
+
+    return _report_sync_final(as_json=as_json, branch=branch, root=root)
+
+
+def _planned_actions(
+    pull: bool, push: bool, ab: dict, unpushed: list, remote: str | None = None
+) -> list[str]:
+    fetch_cmd = (
+        t("sync_action_fetch_remote", remote=remote) if remote else t("sync_action_fetch_all")
+    )
+    actions = [fetch_cmd]
+    if pull and ab["behind"] > 0:
+        actions.append(t("sync_pull_ff"))
+    if push and unpushed:
+        actions.append(t("sync_push_commits", count=str(len(unpushed))))
+    return actions