gitwise-cli 0.24.2__py3-none-any.whl

gitwise/branches.py

@@ -0,0 +1,183 @@
+"""gitwise branches — intelligence dashboard with ahead/behind, merged, stale, worktree info."""
+
+from .git import require_root, stale_branches, worktree_branches
+from .git import run as git_run
+from .i18n import t
+from .output import error, info, print_dim, print_json, print_table
+from .utils.json_envelope import ok_envelope
+
+
+def _parse_branches(raw: str, wt_branches: set[str]) -> list[dict[str, str]]:
+    branches: list[dict[str, str]] = []
+    for line in raw.splitlines():
+        if not line.strip():
+            continue
+        parts = line.split("\t")
+        if len(parts) < 5:
+            continue
+        is_current = parts[0].strip() == "*"
+        name = parts[1].strip()
+        sha = parts[2]
+        subject = parts[3]
+        age = parts[4]
+        tracking = parts[5] if len(parts) > 5 else ""
+        upstream = parts[6] if len(parts) > 6 else ""
+
+        ahead = behind = ""
+        if "[ahead" in tracking:
+            ahead = tracking.split("ahead")[1].split(",")[0].strip().rstrip("]")
+        if "behind" in tracking:
+            behind = tracking.split("behind")[1].strip().rstrip("]")
+
+        branches.append(
+            {
+                "name": name,
+                "current": str(is_current).lower(),
+                "sha": sha,
+                "subject": subject,
+                "age": age,
+                "upstream": upstream,
+                "ahead": ahead,
+                "behind": behind,
+                "tracking": tracking,
+                "in_worktree": str(name in wt_branches).lower(),
+            }
+        )
+    return branches
+
+
+_VALID_SORT_FIELDS = frozenset(
+    {
+        "refname",
+        "-refname",
+        "committerdate",
+        "-committerdate",
+        "creatordate",
+        "-creatordate",
+        "authordate",
+        "-authordate",
+    }
+)
+
+
+def _print_stale_branches(*, names: list[str], as_json: bool) -> int:
+    if not names:
+        info(t("no_stale_branches"))
+        return 0
+    if as_json:
+        print_json(ok_envelope(stale_branches=names, count=len(names)))
+        return 0
+    for branch_name in names:
+        print_dim(branch_name)
+    return 0
+
+
+def _fetch_branch_rows(*, root, remote: bool, sort: str) -> list[dict[str, str]] | None:
+    wt_branches = worktree_branches(cwd=root)
+    ref_pattern = "refs/remotes/" if remote else "refs/heads/"
+    fmt = "%(HEAD)\t%(refname:short)\t%(objectname:short)\t%(subject)\t%(committerdate:relative)\t%(upstream:track)\t%(upstream:short)"
+    result = git_run(
+        ["for-each-ref", f"--sort={sort}", f"--format={fmt}", ref_pattern],
+        cwd=root,
+        check=False,
+    )
+    if result.returncode != 0:
+        error(t("git_ref_failed", error=result.stderr.strip()))
+        return None
+    if not result.stdout.strip():
+        if remote:
+            info(t("no_remote_branches"))
+        else:
+            info(t("no_commits_yet"))
+        return []
+    return _parse_branches(result.stdout, wt_branches)
+
+
+def _build_branch_rows(
+    branches: list[dict[str, str]],
+) -> tuple[list[list[str]], set[int], int | None]:
+    rows: list[list[str]] = []
+    highlight_rows: set[int] = set()
+    current_idx: int | None = None
+    for idx, branch_item in enumerate(branches):
+        sha = branch_item["sha"][:8]
+        subject = branch_item["subject"][:40]
+        age = branch_item.get("age", "")
+        flags: list[str] = []
+        if branch_item.get("ahead"):
+            flags.append(f"↑{branch_item['ahead']}")
+        if branch_item.get("behind"):
+            flags.append(f"↓{branch_item['behind']}")
+        if branch_item.get("in_worktree") == "true":
+            flags.append("wt")
+        if branch_item.get("upstream"):
+            flags.append(f"→{branch_item['upstream']}")
+        status = " ".join(flags) if flags else ""
+        name_display = (
+            f"* {branch_item['name']}" if branch_item["current"] == "true" else branch_item["name"]
+        )
+        rows.append([name_display, sha, subject, age, status])
+        if branch_item["current"] == "true":
+            current_idx = idx
+            highlight_rows.add(idx)
+    return rows, highlight_rows, current_idx
+
+
+def _print_branch_table(branches: list[dict[str, str]]) -> None:
+    columns = [
+        (t("col_branch"), "name"),
+        (t("col_sha"), "sha"),
+        (t("col_subject"), "subject"),
+        (t("col_age"), "age"),
+        (t("col_status"), "status"),
+    ]
+    rows, highlight_rows, current_idx = _build_branch_rows(branches)
+    print_table(
+        title=t("branch_list_title_current", branch=branches[current_idx]["name"])
+        if current_idx is not None
+        else t("branch_list_title"),
+        columns=columns,
+        rows=rows,
+        highlight_rows=highlight_rows,
+    )
+
+
+def _validate_sort_field(sort: str) -> bool:
+    if sort in _VALID_SORT_FIELDS:
+        return True
+    error(t("invalid_sort_field", field=sort))
+    return False
+
+
+def run_branches(
+    *,
+    stale: bool = False,
+    remote: bool = False,
+    sort: str = "refname",
+    as_json: bool = False,
+) -> int:
+    root, err = require_root()
+    if err:
+        return err
+    if root is None:
+        return 1
+
+    if stale:
+        names = stale_branches(cwd=root)
+        return _print_stale_branches(names=names, as_json=as_json)
+
+    if not _validate_sort_field(sort):
+        return 1
+
+    branches = _fetch_branch_rows(root=root, remote=remote, sort=sort)
+    if branches is None:
+        return 1
+    if not branches:
+        return 0
+
+    if as_json:
+        print_json(ok_envelope(branches=branches, count=len(branches)))
+        return 0
+    _print_branch_table(branches)
+
+    return 0

gitwise/clean.py

@@ -0,0 +1,197 @@
+"""Deletes stale [gone] branches with mandatory confirmation. Never silent."""
+
+from pathlib import Path
+
+from .git import (
+    current_branch,
+    require_root,
+    stale_branches,
+    worktree_branches,
+)
+from .git import (
+    run as git_run,
+)
+from .i18n import t
+from .output import (
+    confirm,
+    error,
+    ok,
+    print_blank,
+    print_bracket,
+    print_dim,
+    print_header,
+    print_json,
+    print_success,
+    warn,
+)
+from .utils.json_envelope import error_envelope, ok_envelope
+
+_DEFAULT_PROTECTED: frozenset[str] = frozenset(
+    {"main", "master", "develop", "dev", "trunk", "release"}
+)
+
+
+def _categorize(
+    cwd: Path, extra_protected: set[str] | None = None
+) -> tuple[list[str], list[dict[str, str]]]:
+    """Returns (deletable, skipped_with_reasons) for all stale branches."""
+    protected = _DEFAULT_PROTECTED | (extra_protected or set())
+    checked_out = current_branch(cwd)
+    active_wt = worktree_branches(cwd)
+
+    deletable: list[str] = []
+    skipped: list[dict] = []
+
+    for branch in stale_branches(cwd):
+        if branch in protected:
+            skipped.append({"branch": branch, "reason": t("protected_branch")})
+        elif branch == checked_out:
+            skipped.append({"branch": branch, "reason": t("current_branch_msg")})
+        elif branch in active_wt:
+            skipped.append({"branch": branch, "reason": t("active_in_worktree")})
+        else:
+            deletable.append(branch)
+
+    return deletable, skipped
+
+
+def run_clean(
+    *,
+    branches: bool = False,
+    refs: bool = False,
+    dry_run: bool = False,
+    yes: bool = False,
+    as_json: bool = False,
+) -> int:
+    if refs:
+        error(t("clean_refs_not_implemented"))
+        return 1
+
+    if not branches:
+        error(t("clean_specify_flag"))
+        return 1
+
+    root, err = require_root()
+    if err:
+        return err
+    if root is None:
+        return 1
+    cwd = root
+
+    deletable, skipped = _categorize(cwd)
+
+    if dry_run:
+        if as_json:
+            print_json(
+                ok_envelope(
+                    payload={
+                        "dry_run": True,
+                        "applied": False,
+                        "deletable": deletable,
+                        "skipped": skipped,
+                    }
+                )
+            )
+            return 0
+        if not deletable and not skipped:
+            ok(t("no_stale_branches"))
+            return 0
+        if skipped:
+            print_header(t("protected_stale_branches", count=str(len(skipped))))
+            for s in skipped:
+                print_bracket(s["branch"], s["reason"])
+            print_blank()
+        if not deletable:
+            ok(t("no_deletable_branches"))
+            return 0
+        print_header(t("branches_to_delete", count=str(len(deletable))))
+        for branch in deletable:
+            print_bracket(branch)
+        print_blank()
+        print_dim(t("dry_run_no_delete"))
+        print_dim(t("clean_to_delete"))
+        return 0
+
+    if as_json and not yes:
+        print_json(
+            error_envelope(
+                error=t("yes_required_with_json"),
+                code="yes_required",
+                hint=t("yes_required_hint"),
+            )
+        )
+        return 2
+
+    if not as_json:
+        if not deletable and not skipped:
+            ok(t("no_stale_branches"))
+            return 0
+        if skipped:
+            print_header(t("protected_stale_branches", count=str(len(skipped))))
+            for s in skipped:
+                print_bracket(s["branch"], s["reason"])
+            print_blank()
+        if not deletable:
+            ok(t("no_deletable_branches"))
+            return 0
+        print_header(t("branches_to_delete", count=str(len(deletable))))
+        for branch in deletable:
+            print_bracket(branch)
+        print_blank()
+        if not yes:
+            if not confirm(t("confirm_delete_branches", count=str(len(deletable)))):
+                print_dim(t("cancelled"))
+                return 0
+            print_blank()
+    elif not deletable:
+        print_json(
+            ok_envelope(
+                payload={
+                    "dry_run": False,
+                    "applied": True,
+                    "deleted": [],
+                    "skipped": skipped,
+                    "delete_errors": [],
+                }
+            )
+        )
+        return 0
+
+    deleted: list[str] = []
+    delete_errors: list[dict[str, str]] = []
+    for branch in deletable:
+        r = git_run(["branch", "-D", branch], cwd=cwd, check=False)
+        if r.returncode == 0:
+            deleted.append(branch)
+            if not as_json:
+                print_success(t("branch_deleted", branch=branch))
+        else:
+            delete_errors.append({"branch": branch, "error": r.stderr.strip()})
+            if not as_json:
+                warn(t("could_not_delete", branch=branch, error=r.stderr.strip()))
+
+    if as_json:
+        payload: dict[str, object] = {
+            "dry_run": False,
+            "applied": True,
+            "deleted": deleted,
+            "skipped": skipped,
+            "delete_errors": delete_errors,
+        }
+        if delete_errors:
+            print_json(
+                error_envelope(
+                    error=t("clean_delete_failures", count=str(len(delete_errors))),
+                    code="clean_delete_failures",
+                    payload=payload,
+                )
+            )
+            return 1
+        print_json(ok_envelope(payload=payload))
+        return 0
+
+    if delete_errors:
+        return 1
+    print_blank()
+    ok(t("deleted_count", count=str(len(deletable))))
+    return 0

gitwise/commit.py

@@ -0,0 +1,142 @@
+"""gitwise commit — conventional format validation, GPG enforcement, --amend protection."""
+
+import re
+from pathlib import Path
+
+from .git import PROTECTED_BRANCHES, current_branch, gpg_status, require_root
+from .git import run as git_run
+from .i18n import t
+from .output import error, print_bracket, print_header, print_json
+from .utils.json_envelope import error_envelope, ok_envelope
+
+_CONVENTIONAL_RE = re.compile(
+    r"^(feat|fix|refactor|docs|chore|test|style|perf|ci|build|revert)(\(.+\))?!?: .{1,72}"
+)
+
+
+def _is_pushed(branch: str, cwd: Path) -> bool:
+    r = git_run(["rev-parse", "--verify", branch + "@{u}"], cwd=cwd, check=False)
+    return r.returncode == 0
+
+
+def _compose_message(
+    *,
+    message: str,
+    type: str | None,
+    scope: str | None,
+    breaking: bool,
+) -> str:
+    if _CONVENTIONAL_RE.match(message.split("\n")[0]) and not type:
+        return message
+    if not type:
+        return message
+    prefix = type
+    if scope:
+        prefix += f"({scope})"
+    if breaking:
+        prefix += "!"
+    return f"{prefix}: {message}"
+
+
+def _validate_amend_policy(*, amend: bool, root: Path) -> int:
+    if not amend:
+        return 0
+    branch = current_branch(cwd=root) or ""
+    if branch in PROTECTED_BRANCHES:
+        error(t("commit_amend_protected", branch=branch))
+        return 1
+    if _is_pushed(branch, root):
+        error(t("commit_amend_pushed", branch=branch))
+        return 1
+    return 0
+
+
+def _print_dry_run(*, message: str, amend: bool, root: Path) -> None:
+    print_header(t("dry_run_no_exec"))
+    print_bracket(t("commit_msg_label"), message)
+    if amend:
+        print_bracket(t("commit_amend_label"))
+    branch = current_branch(cwd=root) or ""
+    if branch:
+        print_bracket(t("commit_branch_label"), branch)
+
+
+def _validate_commit_message(message: str) -> bool:
+    if _CONVENTIONAL_RE.match(message.split("\n")[0]):
+        return True
+    error(t("commit_invalid_format"))
+    return False
+
+
+def _execute_commit(*, root: Path, message: str, amend: bool) -> tuple[bool, str]:
+    args = ["commit", "-m", message]
+    if amend:
+        args.append("--amend")
+    result = git_run(args, cwd=root, check=False)
+    if result.returncode == 0:
+        return True, ""
+    return False, t("git_command_failed", cmd="commit", error=result.stderr.strip())
+
+
+def _validate_gpg_ready(root: Path) -> bool:
+    gpg = gpg_status(cwd=root)
+    if gpg["gpgsign_enabled"] and not gpg["ready"]:
+        error(t("gpg_signing_active_no_key"))
+        return False
+    return True
+
+
+def _report_commit_error(*, as_json: bool, err: str) -> int:
+    if as_json:
+        print_json(error_envelope(error=err))
+    else:
+        error(err)
+    return 1
+
+
+def run_commit(
+    *,
+    message: str | None = None,
+    type: str | None = None,
+    scope: str | None = None,
+    breaking: bool = False,
+    amend: bool = False,
+    dry_run: bool = False,
+    as_json: bool = False,
+) -> int:
+    root, err = require_root()
+    if err:
+        return err
+    if root is None:
+        return 1
+
+    amend_policy_rc = _validate_amend_policy(amend=amend, root=root)
+    if amend_policy_rc != 0:
+        return amend_policy_rc
+
+    if message is None:
+        error(t("commit_no_message"))
+        return 1
+
+    full_msg = _compose_message(message=message, type=type, scope=scope, breaking=breaking)
+
+    if not _validate_commit_message(full_msg):
+        return 1
+
+    if not _validate_gpg_ready(root):
+        return 1
+
+    if dry_run:
+        if as_json:
+            print_json(ok_envelope(message=full_msg, amend=amend, dry_run=True))
+        else:
+            _print_dry_run(message=full_msg, amend=amend, root=root)
+        return 0
+
+    success, err = _execute_commit(root=root, message=full_msg, amend=amend)
+    if not success:
+        return _report_commit_error(as_json=as_json, err=err)
+
+    if as_json:
+        print_json(ok_envelope(message=full_msg, amend=amend))
+    return 0

gitwise/conflicts.py

@@ -0,0 +1,112 @@
+"""gitwise conflicts — conflict detection and resolution helper."""
+
+from pathlib import Path
+
+from .git import require_root
+from .git import run as git_run
+from .i18n import t
+from .output import error, ok, print_accent, print_blank, print_dim, print_header, print_json
+from .utils.json_envelope import error_envelope, ok_envelope
+from .utils.parsing import stripped_non_empty_lines, to_int
+
+
+def _find_conflict_files(root: Path) -> list[str]:
+    r = git_run(["diff", "--name-only", "--diff-filter=U"], cwd=root, check=False)
+    if r.returncode != 0 or not r.stdout.strip():
+        return []
+    return stripped_non_empty_lines(r.stdout)
+
+
+def _conflict_markers(root: Path, filepath: str) -> int:
+    r = git_run(["grep", "-c", "<<<<<<< ", "--", filepath], cwd=root, check=False)
+    if r.returncode != 0:
+        return 0
+    count = 0
+    for line in r.stdout.splitlines():
+        marker_count = line.rsplit(":", 1)[-1]
+        count += max(to_int(marker_count, default=0), 0)
+    return count
+
+
+def _resolve_all_conflicts(*, root: Path, conflicts: list[str], strategy: str) -> int:
+    checkout_flag = "--ours" if strategy == "ours" else "--theirs"
+    result = git_run(["checkout", checkout_flag, "--"] + conflicts, cwd=root, check=False)
+    if result.returncode != 0:
+        error(result.stderr.strip())
+        return 1
+    git_run(["add", "--"] + conflicts, cwd=root, check=False)
+    return 0
+
+
+def _conflict_details(root: Path, conflicts: list[str]) -> list[dict[str, str | int]]:
+    details: list[dict[str, str | int]] = []
+    for file_path in conflicts:
+        markers = _conflict_markers(root, file_path)
+        details.append({"file": file_path, "markers": markers})
+    return details
+
+
+def _report_no_conflicts(*, as_json: bool) -> int:
+    if as_json:
+        print_json(ok_envelope(conflicts=[], count=0))
+        return 0
+    ok(t("conflicts_none"))
+    return 0
+
+
+def _resolve_by_strategy(*, root: Path, conflicts: list[str], strategy: str, as_json: bool) -> int:
+    rc = _resolve_all_conflicts(root=root, conflicts=conflicts, strategy=strategy)
+    if rc != 0:
+        return rc
+    if as_json:
+        print_json(ok_envelope(resolved=len(conflicts), strategy=strategy))
+        return 0
+    key = "conflicts_resolved_ours" if strategy == "ours" else "conflicts_resolved_theirs"
+    ok(t(key, count=str(len(conflicts))))
+    return 0
+
+
+def _report_conflicts(*, details: list[dict[str, str | int]], count: int, as_json: bool) -> int:
+    if as_json:
+        print_json(error_envelope(error=t("merge_conflicts"), conflicts=details, count=count))
+        return 0
+    print_header(t("conflicts_found", count=str(count)))
+    for detail in details:
+        print_accent(f"  {detail['file']}  ({detail['markers']} {t('markers_label')})")
+    print_blank()
+    print_dim(t("conflicts_hint"))
+    return 1
+
+
+def run_conflicts(
+    *,
+    ours: bool = False,
+    theirs: bool = False,
+    as_json: bool = False,
+) -> int:
+    root, err = require_root()
+    if err:
+        return err
+    if root is None:
+        return 1
+
+    conflicts = _find_conflict_files(root)
+
+    if not conflicts:
+        return _report_no_conflicts(as_json=as_json)
+
+    if ours:
+        return _resolve_by_strategy(
+            root=root, conflicts=conflicts, strategy="ours", as_json=as_json
+        )
+
+    if theirs:
+        return _resolve_by_strategy(
+            root=root,
+            conflicts=conflicts,
+            strategy="theirs",
+            as_json=as_json,
+        )
+
+    details = _conflict_details(root, conflicts)
+    return _report_conflicts(details=details, count=len(conflicts), as_json=as_json)