gitwise-cli 0.24.2__py3-none-any.whl

gitwise/tag.py

@@ -0,0 +1,252 @@
+"""gitwise tag — semver-aware tag management (list/create/delete)."""
+
+import re
+from pathlib import Path
+
+from .git import require_root, validate_ref
+from .git import run as git_run
+from .i18n import t
+from .output import (
+    confirm,
+    error,
+    ok,
+    print_bracket,
+    print_header,
+    print_json,
+    print_table,
+    warn,
+)
+from .utils.json_envelope import error_envelope, ok_envelope
+
+_SEMVER_RE = re.compile(r"^v?(\d+)\.(\d+)\.(\d+)(-[a-zA-Z0-9.]+)?(\+[a-zA-Z0-9.]+)?$")
+
+
+def _list_tags(root: Path) -> list[dict[str, str]]:
+    r = git_run(
+        [
+            "for-each-ref",
+            "--format=%(refname:short)\t%(objectname:short)\t%(creatordate:iso)",
+            "refs/tags/",
+        ],
+        cwd=root,
+        check=False,
+    )
+    if r.returncode != 0 or not r.stdout.strip():
+        return []
+    tags: list[dict[str, str]] = []
+    for line in r.stdout.splitlines():
+        parts = line.split("\t", 2)
+        if len(parts) < 3:
+            continue
+        tags.append({"name": parts[0], "sha": parts[1], "date": parts[2]})
+    return tags
+
+
+def _latest_semver(root: Path) -> dict[str, str] | None:
+    tags = _list_tags(root)
+    semver_tags = [tg for tg in tags if _SEMVER_RE.match(tg["name"])]
+    if not semver_tags:
+        return None
+
+    def _sort_key(tg: dict[str, str]) -> tuple[int, ...]:
+        m = _SEMVER_RE.match(tg["name"])
+        if not m:
+            return (0, 0, 0)
+        return (int(m.group(1)), int(m.group(2)), int(m.group(3)))
+
+    semver_tags.sort(key=_sort_key, reverse=True)
+    return semver_tags[0]
+
+
+def _bump_version(version: str, part: str) -> str:
+    m = _SEMVER_RE.match(version)
+    if not m:
+        return version
+    major, minor, patch = int(m.group(1)), int(m.group(2)), int(m.group(3))
+    pre = m.group(4) or ""
+    build = m.group(5) or ""
+    prefix = "v" if version.startswith("v") else ""
+    if part == "major":
+        major += 1
+        minor = patch = 0
+    elif part == "minor":
+        minor += 1
+        patch = 0
+    else:
+        patch += 1
+    return f"{prefix}{major}.{minor}.{patch}{pre}{build}"
+
+
+def _print_tag_list(tags: list[dict[str, str]]) -> None:
+    if not tags:
+        ok(t("tag_empty"))
+        return
+    columns = [
+        (t("col_tag"), "name"),
+        (t("col_sha"), "sha"),
+        (t("col_date"), "date"),
+    ]
+    rows: list[list[str]] = []
+    highlight_rows: set[int] = set()
+    for i, tag_item in enumerate(tags):
+        rows.append([tag_item["name"], tag_item["sha"], tag_item["date"]])
+        if _SEMVER_RE.match(tag_item["name"]):
+            highlight_rows.add(i)
+    print_table(
+        title=t("tag_list_title"),
+        columns=columns,
+        rows=rows,
+        highlight_rows=highlight_rows,
+    )
+
+
+def _resolve_tag_name(
+    *,
+    root: Path,
+    bump: str | None,
+    name: str | None,
+) -> str | None:
+    if bump:
+        latest = _latest_semver(root)
+        base = latest["name"] if latest else "0.0.0"
+        return _bump_version(base, bump)
+    return name
+
+
+def _run_tag_list(*, root: Path, as_json: bool) -> int:
+    tags = _list_tags(root)
+    if as_json:
+        print_json(ok_envelope(tags=tags, count=len(tags)))
+        return 0
+    _print_tag_list(tags)
+    return 0
+
+
+def _run_tag_latest(*, root: Path, as_json: bool) -> int:
+    latest = _latest_semver(root)
+    if as_json:
+        print_json(ok_envelope(latest=latest))
+        return 0
+    if latest:
+        print_header(t("tag_latest_title"))
+        print_bracket(latest["name"], latest["sha"])
+    else:
+        warn(t("tag_no_semver"))
+    return 0
+
+
+def _run_tag_create(
+    *,
+    root: Path,
+    bump: str | None,
+    name: str | None,
+    message: str | None,
+    dry_run: bool,
+    as_json: bool,
+) -> int:
+    tag_name = _resolve_tag_name(root=root, bump=bump, name=name)
+    if not tag_name:
+        error(t("tag_name_required"))
+        return 1
+    if not validate_ref(tag_name):
+        error(t("invalid_ref", ref=tag_name))
+        return 1
+
+    args = ["tag", tag_name]
+    if message:
+        args = ["tag", "-a", tag_name, "-m", message]
+
+    if dry_run:
+        ok(t("tag_create_dry", name=tag_name))
+        return 0
+
+    result = git_run(args, cwd=root, check=False)
+    if result.returncode != 0:
+        err = t("git_command_failed", cmd="tag", error=result.stderr.strip())
+        if as_json:
+            print_json(error_envelope(error=err))
+        else:
+            error(err)
+        return 1
+
+    if as_json:
+        print_json(ok_envelope(created=tag_name))
+        return 0
+    ok(t("tag_created", name=tag_name))
+    return 0
+
+
+def _run_tag_delete(
+    *,
+    root: Path,
+    name: str | None,
+    yes: bool,
+    dry_run: bool,
+    as_json: bool,
+) -> int:
+    if not name:
+        error(t("tag_name_required"))
+        return 1
+    if not validate_ref(name):
+        error(t("invalid_ref", ref=name))
+        return 1
+    if dry_run:
+        ok(t("tag_delete_dry", name=name))
+        return 0
+    if not yes and not confirm(t("confirm_tag_delete", name=name)):
+        warn(t("aborted"))
+        return 1
+
+    result = git_run(["tag", "-d", name], cwd=root, check=False)
+    if result.returncode != 0:
+        err = t("git_command_failed", cmd="tag -d", error=result.stderr.strip())
+        if as_json:
+            print_json(error_envelope(error=err))
+        else:
+            error(err)
+        return 1
+
+    if as_json:
+        print_json(ok_envelope(deleted=name))
+        return 0
+    ok(t("tag_deleted", name=name))
+    return 0
+
+
+def run_tag(
+    action: str = "list",
+    name: str | None = None,
+    *,
+    bump: str | None = None,
+    message: str | None = None,
+    dry_run: bool = False,
+    yes: bool = False,
+    as_json: bool = False,
+) -> int:
+    root, err = require_root()
+    if err:
+        return err
+    if root is None:
+        return 1
+
+    if action == "list":
+        return _run_tag_list(root=root, as_json=as_json)
+
+    if action == "latest":
+        return _run_tag_latest(root=root, as_json=as_json)
+
+    if action == "create":
+        return _run_tag_create(
+            root=root,
+            bump=bump,
+            name=name,
+            message=message,
+            dry_run=dry_run,
+            as_json=as_json,
+        )
+
+    if action == "delete":
+        return _run_tag_delete(root=root, name=name, yes=yes, dry_run=dry_run, as_json=as_json)
+
+    error(t("tag_unknown_action", action=action))
+    return 1

gitwise/undo.py

@@ -0,0 +1,145 @@
+"""gitwise undo — reflog-based undo to any previous HEAD state."""
+
+from .git import require_root, validate_ref
+from .git import run as git_run
+from .i18n import t
+from .output import confirm, error, print_bracket, print_dim, print_header, print_json
+from .utils.json_envelope import ok_envelope
+
+
+def _resolve_undo_target(
+    *, ref: str | None, entries: list[dict[str, str]], steps: int
+) -> str | None:
+    if ref:
+        if not validate_ref(ref):
+            error(t("invalid_ref", ref=ref))
+            return None
+        return ref
+    if len(entries) >= steps + 1:
+        return entries[steps]["hash"]
+    error(t("undo_not_enough_history"))
+    return None
+
+
+def _print_undo_dry_run(*, target: str, soft: bool) -> None:
+    print_header(t("undo_dry_run_title"))
+    mode = "--soft" if soft else "--hard"
+    print_bracket(f"git reset {mode}", target[:12])
+
+
+def _reset_to_target(*, root, target: str, soft: bool) -> int:
+    args = ["reset", "--soft" if soft else "--hard", target]
+    result = git_run(args, cwd=root, check=False)
+    if result.returncode != 0:
+        error(result.stderr.strip())
+        return 1
+    return 0
+
+
+def _load_reflog_entries(*, root, steps: int) -> list[dict[str, str]] | None:
+    result = git_run(
+        ["reflog", "--format=%H|gd-ref:%gd|gs:%gs|msg:%s", f"--max-count={steps + 10}"],
+        cwd=root,
+        check=False,
+    )
+    if result.returncode != 0:
+        error(t("undo_reflog_failed"))
+        return None
+    entries = _parse_reflog(result.stdout)
+    if not entries:
+        error(t("undo_no_entries"))
+        return None
+    return entries
+
+
+def _run_undo_dry_run(
+    *, as_json: bool, target: str, soft: bool, entries: list[dict[str, str]], steps: int
+) -> int:
+    if as_json:
+        print_json(
+            ok_envelope(
+                target=target,
+                soft=soft,
+                dry_run=True,
+                entries=entries[: steps + 1],
+            )
+        )
+    else:
+        _print_undo_dry_run(target=target, soft=soft)
+    return 0
+
+
+def _confirm_hard_reset(*, soft: bool, yes: bool, target: str) -> bool:
+    if soft or yes:
+        return True
+    if confirm(t("undo_confirm_hard", ref=target[:12])):
+        return True
+    print_dim(t("cancelled"))
+    return False
+
+
+def _report_undo_complete(*, as_json: bool, target: str, soft: bool) -> int:
+    if as_json:
+        print_json(ok_envelope(target=target, soft=soft))
+        return 0
+    print_header(t("undo_complete_title"))
+    print_bracket(t("undo_reset_to"), target[:12])
+    return 0
+
+
+def _parse_reflog(raw: str) -> list[dict[str, str]]:
+    entries: list[dict[str, str]] = []
+    for line in raw.splitlines():
+        parts = line.split("|", 3)
+        if len(parts) >= 4:
+            entries.append(
+                {
+                    "hash": parts[0].strip(),
+                    "ref": parts[1].strip(),
+                    "action": parts[2].strip(),
+                    "message": parts[3].strip(),
+                }
+            )
+    return entries
+
+
+def run_undo(
+    *,
+    ref: str | None = None,
+    soft: bool = False,
+    steps: int = 1,
+    dry_run: bool = False,
+    yes: bool = False,
+    as_json: bool = False,
+) -> int:
+    root, err = require_root()
+    if err:
+        return err
+    if root is None:
+        return 1
+
+    entries = _load_reflog_entries(root=root, steps=steps)
+    if entries is None:
+        return 1
+
+    target = _resolve_undo_target(ref=ref, entries=entries, steps=steps)
+    if target is None:
+        return 1
+
+    if dry_run:
+        return _run_undo_dry_run(
+            as_json=as_json,
+            target=target,
+            soft=soft,
+            entries=entries,
+            steps=steps,
+        )
+
+    if not _confirm_hard_reset(soft=soft, yes=yes, target=target):
+        return 0
+
+    reset_rc = _reset_to_target(root=root, target=target, soft=soft)
+    if reset_rc != 0:
+        return reset_rc
+
+    return _report_undo_complete(as_json=as_json, target=target, soft=soft)

gitwise/update.py

@@ -0,0 +1,42 @@
+"""Update gitwise via git pull."""
+
+from pathlib import Path
+
+from .git import run as git_run
+from .i18n import t
+from .output import error, info, print_dim, print_header, print_json
+from .utils.json_envelope import error_envelope, ok_envelope
+
+
+def run_update(*, dry_run: bool = False, as_json: bool = False) -> int:
+    install_dir = Path(__file__).parent.parent
+    if not (install_dir / ".git").is_dir():
+        if as_json:
+            print_json(error_envelope(error=t("update_requires_git_clone")))
+        else:
+            error(t("update_requires_git_clone"))
+        return 1
+    if dry_run:
+        if as_json:
+            print_json(ok_envelope(dry_run=True, dir=str(install_dir)))
+            return 0
+        print_dim(t("update_dry_run", dir=str(install_dir)))
+        return 0
+    print_header(t("updating_from", dir=str(install_dir)))
+    r = git_run(["pull", "--ff-only"], cwd=install_dir, check=False)
+    if r.returncode == 0 and r.stdout.strip() and r.stdout.strip() != "Already up to date.":
+        if as_json:
+            print_json(ok_envelope(updated=True, output=r.stdout.strip()))
+            return 0
+        for line in r.stdout.strip().splitlines():
+            info(line)
+    elif r.returncode != 0:
+        if as_json:
+            print_json(error_envelope(error=r.stderr.strip() or t("error_updating")))
+            return 1
+        error(r.stderr.strip() or t("error_updating"))
+        return r.returncode
+    elif as_json:
+        print_json(ok_envelope(updated=False, output=t("already_up_to_date")))
+        return 0
+    return r.returncode

gitwise/utils/__init__.py

@@ -0,0 +1 @@
+"""Shared utility modules for gitwise."""

gitwise/utils/git_output.py

@@ -0,0 +1,51 @@
+"""Reusable parsers for git command output formats."""
+
+
+def parse_diffstat_entries(raw: str, *, default_status: str | None = None) -> list[dict[str, str]]:
+    entries: list[dict[str, str]] = []
+    for line in raw.splitlines():
+        if "|" not in line:
+            continue
+        path_raw, changes_raw = line.split("|", 1)
+        path = path_raw.strip()
+        changes = changes_raw.strip()
+        if not path:
+            continue
+        entry: dict[str, str] = {"path": path, "changes": changes}
+        if default_status is not None:
+            entry["status"] = default_status
+        entries.append(entry)
+    return entries
+
+
+def parse_name_status_entries(raw: str) -> list[dict[str, str]]:
+    entries: list[dict[str, str]] = []
+    for line in raw.splitlines():
+        parts = line.split("\t")
+        if len(parts) < 2:
+            continue
+        status = parts[0].strip()
+        code = status[:1].upper() if status else ""
+        if code in {"R", "C"} and len(parts) >= 3:
+            old_path = parts[1].strip()
+            path = parts[2].strip()
+            if not path:
+                continue
+            entry: dict[str, str] = {"status": status, "path": path}
+            if code and code != status:
+                entry["code"] = code
+            if old_path:
+                entry["old_path"] = old_path
+            if len(status) > 1 and status[1:].isdigit():
+                entry["score"] = status[1:]
+            entries.append(entry)
+            continue
+
+        path = parts[-1].strip()
+        if not path:
+            continue
+        entry = {"status": status, "path": path}
+        if code and code != status:
+            entry["code"] = code
+        entries.append(entry)
+    return entries

gitwise/utils/json_envelope.py

@@ -0,0 +1,58 @@
+"""Helpers for standardized JSON envelopes in CLI commands."""
+
+from collections.abc import Mapping
+
+
+def ok_envelope(
+    *,
+    payload: Mapping[str, object] | None = None,
+    version: int = 2,
+    **extra: object,
+) -> dict[str, object]:
+    data: dict[str, object] = {}
+    if payload is not None:
+        data.update(payload)
+    data.update(extra)
+    data["v"] = version
+    data["ok"] = True
+    return data
+
+
+def error_envelope(
+    *,
+    error: str,
+    code: str | None = None,
+    hint: str | None = None,
+    payload: Mapping[str, object] | None = None,
+    version: int = 2,
+    **extra: object,
+) -> dict[str, object]:
+    data: dict[str, object] = {}
+    if payload is not None:
+        data.update(payload)
+    data.update(extra)
+    data["v"] = version
+    data["ok"] = False
+    data["error"] = error
+    err_item: dict[str, object] = {
+        "code": code or "error",
+        "message": error,
+    }
+    if hint:
+        err_item["hint"] = hint
+    data["errors"] = [err_item]
+    return data
+
+
+def passthrough_envelope(
+    *,
+    payload: Mapping[str, object] | None = None,
+    version: int = 2,
+    **extra: object,
+) -> dict[str, object]:
+    data: dict[str, object] = {}
+    if payload is not None:
+        data.update(payload)
+    data.update(extra)
+    data["v"] = version
+    return data

gitwise/utils/parsing.py

@@ -0,0 +1,34 @@
+"""Shared parsing helpers for CLI text/number normalization."""
+
+
+def non_empty_lines(text: str) -> list[str]:
+    return [line for line in text.splitlines() if line.strip()]
+
+
+def stripped_non_empty_lines(text: str) -> list[str]:
+    return [line.strip() for line in text.splitlines() if line.strip()]
+
+
+def to_int(value: object, *, default: int = 0) -> int:
+    if isinstance(value, int):
+        return value
+    try:
+        return int(str(value).strip())
+    except (ValueError, TypeError):
+        return default
+
+
+def parse_two_ints(text: str) -> tuple[int, int] | None:
+    parts = text.strip().split()
+    if len(parts) != 2:
+        return None
+    try:
+        return int(parts[0]), int(parts[1])
+    except (ValueError, TypeError):
+        return None
+
+
+def dict_list(value: object) -> list[dict[str, object]]:
+    if not isinstance(value, list):
+        return []
+    return [item for item in value if isinstance(item, dict)]