gitwise-cli 0.24.2__py3-none-any.whl

gitwise/log.py

@@ -0,0 +1,329 @@
+"""gitwise log — pretty git log with filters and JSON output."""
+
+import subprocess
+from pathlib import Path
+
+from .git import require_root, validate_author_pattern, validate_grep_pattern
+from .git import run as git_run
+from .i18n import t
+from .output import bat_pipe, error, info, print_json, print_table
+from .utils.json_envelope import ok_envelope
+
+
+def _build_log_args(
+    *,
+    author: str | None = None,
+    grep: str | None = None,
+    since: str | None = None,
+    until: str | None = None,
+    file: str | None = None,
+    oneline: bool = False,
+    graph: bool = False,
+    max_count: int = 20,
+) -> list[str]:
+    args = ["log", f"--max-count={max_count}"]
+    if graph:
+        args.append("--graph")
+    if oneline:
+        args.append("--oneline")
+    else:
+        args.append("--format=%h\t%an\t%ad\t%s")
+        args.append("--date=short")
+    if author:
+        if not validate_author_pattern(author):
+            error(t("invalid_author_pattern", pattern=author[:50]))
+            raise ValueError(f"unsafe author pattern: {author[:50]}")
+        args.append(f"--author={author}")
+    if grep:
+        if not validate_grep_pattern(grep):
+            error(t("invalid_grep_pattern", pattern=grep[:50]))
+            raise ValueError(f"unsafe grep pattern: {grep[:50]}")
+        args.append(f"--grep={grep}")
+    if since:
+        args.append(f"--since={since}")
+    if until:
+        args.append(f"--until={until}")
+    if file:
+        args.append("--")
+        args.append(file)
+    return args
+
+
+def _build_log_json_args(
+    *,
+    author: str | None = None,
+    grep: str | None = None,
+    since: str | None = None,
+    until: str | None = None,
+    file: str | None = None,
+    max_count: int = 20,
+) -> list[str]:
+    args = [
+        "log",
+        f"--max-count={max_count}",
+        "--format=%H%n%h%n%an%n%ae%n%ad%n%s%n%P%n---END---",
+        "--date=iso",
+    ]
+    if author:
+        if not validate_author_pattern(author):
+            error(t("invalid_author_pattern", pattern=author[:50]))
+            raise ValueError(f"unsafe author pattern: {author[:50]}")
+        args.append(f"--author={author}")
+    if grep:
+        if not validate_grep_pattern(grep):
+            error(t("invalid_grep_pattern", pattern=grep[:50]))
+            raise ValueError(f"unsafe grep pattern: {grep[:50]}")
+        args.append(f"--grep={grep}")
+    if since:
+        args.append(f"--since={since}")
+    if until:
+        args.append(f"--until={until}")
+    if file:
+        args.append("--")
+        args.append(file)
+    return args
+
+
+def _parse_log_json(raw: str) -> list[dict[str, str]]:
+    commits: list[dict[str, str]] = []
+    entries = raw.split("---END---")
+    for entry in entries:
+        lines = entry.strip().splitlines()
+        if len(lines) >= 7:
+            commits.append(
+                {
+                    "hash": lines[0],
+                    "short_hash": lines[1],
+                    "author": lines[2],
+                    "email": lines[3],
+                    "date": lines[4],
+                    "subject": lines[5],
+                    "parents": lines[6],
+                }
+            )
+        elif len(lines) == 6:
+            commits.append(
+                {
+                    "hash": lines[0],
+                    "short_hash": lines[1],
+                    "author": lines[2],
+                    "email": lines[3],
+                    "date": lines[4],
+                    "subject": lines[5],
+                    "parents": "",
+                }
+            )
+    return commits
+
+
+def _enrich_with_stats(commits: list[dict[str, str]], cwd: Path) -> None:
+    if not commits:
+        return
+    hashes = "\n".join(c["hash"] for c in commits)
+    r = subprocess.run(
+        ["git", "diff-tree", "--stdin", "--no-commit-id", "--stat", "-r"],
+        input=hashes,
+        capture_output=True,
+        text=True,
+        cwd=cwd,
+        timeout=120,
+    )
+    if r.returncode != 0:
+        for c in commits:
+            c["stats"] = ""
+        return
+    stats_by_hash: dict[str, str] = {}
+    current_hash = ""
+    current_lines: list[str] = []
+    for line in r.stdout.splitlines():
+        if not line and current_hash:
+            stats_by_hash[current_hash] = "\n".join(current_lines).strip()
+            current_hash = ""
+            current_lines = []
+            continue
+        if len(line) >= 40 and all(c in "0123456789abcdef" for c in line[:40]):
+            if current_hash and current_lines:
+                stats_by_hash[current_hash] = "\n".join(current_lines).strip()
+            current_hash = line.strip()
+            current_lines = []
+        else:
+            current_lines.append(line)
+    if current_hash and current_lines:
+        stats_by_hash[current_hash] = "\n".join(current_lines).strip()
+    for c in commits:
+        c["stats"] = stats_by_hash.get(c["hash"], "")
+
+
+def _parse_log_table(raw: str) -> list[list[str]]:
+    rows: list[list[str]] = []
+    for line in raw.splitlines():
+        if not line.strip():
+            continue
+        parts = line.split("\t")
+        if len(parts) >= 4:
+            rows.append(
+                [
+                    parts[0],
+                    parts[1],
+                    parts[2],
+                    parts[3],
+                ]
+            )
+        elif len(parts) >= 3:
+            rows.append(
+                [
+                    parts[0],
+                    parts[1],
+                    parts[2],
+                    "",
+                ]
+            )
+    return rows
+
+
+def _run_log_json(
+    *,
+    root: Path,
+    author: str | None,
+    grep: str | None,
+    since: str | None,
+    until: str | None,
+    file: str | None,
+    max_count: int,
+) -> int:
+    try:
+        args = _build_log_json_args(
+            author=author,
+            grep=grep,
+            since=since,
+            until=until,
+            file=file,
+            max_count=max_count,
+        )
+    except ValueError:
+        return 1
+    result = git_run(args, cwd=root, check=False)
+    if result.returncode != 0:
+        if "does not have any commits yet" in result.stderr:
+            print_json(ok_envelope(commits=[], count=0))
+            return 0
+        error(t("git_log_failed", error=result.stderr.strip()))
+        return 1
+    commits = _parse_log_json(result.stdout)
+    _enrich_with_stats(commits, root)
+    print_json(ok_envelope(commits=commits, count=len(commits)))
+    return 0
+
+
+def _run_log_human(
+    *,
+    root: Path,
+    oneline: bool,
+    graph: bool,
+    author: str | None,
+    grep: str | None,
+    since: str | None,
+    until: str | None,
+    file: str | None,
+    max_count: int,
+) -> int:
+    try:
+        args = _build_log_args(
+            oneline=oneline,
+            graph=graph,
+            author=author,
+            grep=grep,
+            since=since,
+            until=until,
+            file=file,
+            max_count=max_count,
+        )
+    except ValueError:
+        return 1
+    result = git_run(args, cwd=root, check=False)
+    if result.returncode != 0:
+        if result.stderr and "does not have any commits yet" in result.stderr:
+            info(t("no_commits_yet"))
+            return 0
+        error(t("git_log_failed", error=result.stderr.strip()))
+        return 1
+    if not result.stdout.strip():
+        info(t("no_commits_yet"))
+        return 0
+    if _run_log_human_plain_or_graph(raw=result.stdout, graph=graph, oneline=oneline):
+        return 0
+
+    return _print_log_table(result.stdout)
+
+
+def _print_log_table(raw: str) -> int:
+    rows = _parse_log_table(raw)
+    if not rows:
+        info(t("no_commits_yet"))
+        return 0
+    columns = [
+        (t("col_sha"), "sha"),
+        (t("col_author"), "author"),
+        (t("col_date"), "date"),
+        (t("col_subject"), "subject"),
+    ]
+    print_table(
+        title=t("git_log_title"),
+        columns=columns,
+        rows=rows,
+        no_wrap_columns={0, 2},
+        min_widths={0: 7, 2: 10},
+        max_widths={0: 10, 1: 20},
+        overflow_columns={0: "crop", 1: "ellipsis", 2: "crop", 3: "ellipsis"},
+        column_ratios={3: 4},
+    )
+    return 0
+
+
+def _run_log_human_plain_or_graph(*, raw: str, graph: bool, oneline: bool) -> bool:
+    if graph or oneline:
+        bat_pipe(raw, language="gitlog")
+        return True
+    return False
+
+
+def run_log(
+    *,
+    as_json: bool = False,
+    oneline: bool = False,
+    graph: bool = False,
+    author: str | None = None,
+    grep: str | None = None,
+    since: str | None = None,
+    until: str | None = None,
+    file: str | None = None,
+    max_count: int = 20,
+) -> int:
+    root, err = require_root()
+    if err:
+        return err
+    if root is None:
+        return 1
+
+    if as_json:
+        return _run_log_json(
+            root=root,
+            author=author,
+            grep=grep,
+            since=since,
+            until=until,
+            file=file,
+            max_count=max_count,
+        )
+
+    return _run_log_human(
+        root=root,
+        oneline=oneline,
+        graph=graph,
+        author=author,
+        grep=grep,
+        since=since,
+        until=until,
+        file=file,
+        max_count=max_count,
+    )

gitwise/merge.py

@@ -0,0 +1,193 @@
+"""gitwise merge — merge/rebase with pre-flight checks."""
+
+from pathlib import Path
+
+from .git import current_branch, 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,
+    warn,
+)
+from .utils.json_envelope import error_envelope, ok_envelope
+from .utils.parsing import to_int
+
+
+def _has_uncommitted(root: Path) -> bool:
+    r = git_run(["status", "--porcelain"], cwd=root, check=False)
+    return r.returncode == 0 and bool(r.stdout.strip())
+
+
+def _branch_exists(root: Path, name: str) -> bool:
+    r = git_run(["rev-parse", "--verify", "refs/heads/" + name], cwd=root, check=False)
+    return r.returncode == 0
+
+
+def _validate_merge_target(*, root: Path, branch: str, cur: str | None) -> str | None:
+    if cur is None:
+        return t("merge_detached_head")
+    if not validate_ref(branch):
+        return t("invalid_ref", ref=branch)
+    if not _branch_exists(root, branch):
+        return t("merge_branch_not_found", branch=branch)
+    if branch == cur:
+        return t("merge_same_branch")
+    return None
+
+
+def _ahead_behind_counts(*, root: Path, branch: str) -> tuple[int, int]:
+    ahead = git_run(["rev-list", "--count", f"{branch}..HEAD"], cwd=root, check=False)
+    behind = git_run(["rev-list", "--count", f"HEAD..{branch}"], cwd=root, check=False)
+    ahead_count = to_int(ahead.stdout, default=0) if ahead.returncode == 0 else 0
+    behind_count = to_int(behind.stdout, default=0) if behind.returncode == 0 else 0
+    return ahead_count, behind_count
+
+
+def _merge_warnings(*, root: Path, branch: str, ahead_count: int, behind_count: int) -> list[str]:
+    warnings: list[str] = []
+    if _has_uncommitted(root):
+        warnings.append(t("merge_uncommitted"))
+    if ahead_count > 0 and behind_count > 0:
+        warnings.append(t("merge_diverged", ahead=str(ahead_count), behind=str(behind_count)))
+    return warnings
+
+
+def _handle_merge_dry_run(
+    *,
+    as_json: bool,
+    rebase: bool,
+    branch: str,
+    cur: str,
+    ahead_count: int,
+    behind_count: int,
+    warnings: list[str],
+) -> int:
+    if as_json:
+        print_json(
+            ok_envelope(
+                dry_run=True,
+                action="rebase" if rebase else "merge",
+                branch=branch,
+                current=cur,
+                ahead=ahead_count,
+                behind=behind_count,
+                warnings=warnings,
+            )
+        )
+        return 0
+    action = t("merge_rebase_label") if rebase else t("merge_merge_label")
+    print_header(f"{action}: {branch} -> {cur}")
+    if ahead_count or behind_count:
+        print_bracket(t("status_ahead_label"), str(ahead_count))
+        print_bracket(t("status_behind_label"), str(behind_count))
+    for warning_msg in warnings:
+        warn(warning_msg)
+    return 0
+
+
+def _execute_merge(*, root: Path, branch: str, rebase: bool, no_ff: bool) -> tuple[bool, str]:
+    if rebase:
+        args = ["rebase", branch]
+    else:
+        args = ["merge"]
+        if no_ff:
+            args.append("--no-ff")
+        args.append(branch)
+    result = git_run(args, cwd=root, check=False)
+    if result.returncode == 0:
+        return True, ""
+    err = (
+        t("merge_conflicts")
+        if ("CONFLICT" in result.stdout or "CONFLICT" in result.stderr)
+        else t("git_command_failed", cmd="merge/rebase", error=result.stderr.strip())
+    )
+    return False, err
+
+
+def _confirm_merge_warnings(*, warnings: list[str], yes: bool) -> bool:
+    if not warnings:
+        return True
+    for warning_msg in warnings:
+        warn(warning_msg)
+    if yes:
+        return True
+    if confirm(t("merge_proceed")):
+        return True
+    warn(t("aborted"))
+    return False
+
+
+def _report_merge_success(*, as_json: bool, branch: str, cur: str, rebase: bool) -> int:
+    if as_json:
+        print_json(ok_envelope(merged=branch, into=cur))
+        return 0
+    label = (
+        t("merge_rebased", branch=branch, into=cur)
+        if rebase
+        else t("merge_ok", branch=branch, into=cur)
+    )
+    ok(label)
+    return 0
+
+
+def _report_merge_error(*, as_json: bool, err: str) -> int:
+    if as_json:
+        print_json(error_envelope(error=err, code="merge_error", hint=t("merge_hint")))
+    else:
+        error(err, hint=t("merge_hint"))
+    return 1
+
+
+def run_merge(
+    branch: str,
+    *,
+    rebase: bool = False,
+    no_ff: bool = False,
+    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
+
+    cur = current_branch(root)
+    target_err = _validate_merge_target(root=root, branch=branch, cur=cur)
+    if target_err is not None:
+        return _report_merge_error(as_json=as_json, err=target_err)
+    assert cur is not None
+
+    ahead_count, behind_count = _ahead_behind_counts(root=root, branch=branch)
+    warnings = _merge_warnings(
+        root=root,
+        branch=branch,
+        ahead_count=ahead_count,
+        behind_count=behind_count,
+    )
+
+    if dry_run:
+        return _handle_merge_dry_run(
+            as_json=as_json,
+            rebase=rebase,
+            branch=branch,
+            cur=cur,
+            ahead_count=ahead_count,
+            behind_count=behind_count,
+            warnings=warnings,
+        )
+
+    if not _confirm_merge_warnings(warnings=warnings, yes=yes):
+        return 1
+
+    success, err = _execute_merge(root=root, branch=branch, rebase=rebase, no_ff=no_ff)
+    if not success:
+        return _report_merge_error(as_json=as_json, err=err)
+
+    return _report_merge_success(as_json=as_json, branch=branch, cur=cur, rebase=rebase)