gitwise-cli 0.28.0__tar.gz → 0.29.0__tar.gz

{gitwise_cli-0.28.0 → gitwise_cli-0.29.0}/CHANGELOG.md

@@ -3,6 +3,22 @@
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## v0.29.0 (2026-06-19)
+
+### Feat
+
+- in-progress safety + merge --abort/--continue (Sprint 1) (#65)
+- detect in-progress operations and guard suggest/commit (Sprint 1)
+
+### Fix
+
+- **in_progress**: use os.path.realpath and explicit subprocess timeout (CodeRabbit)
+- **merge**: pick rebase subcommand when state=rebase (gemini PR#65 finding)
+
+### Refactor
+
+- **merge**: extract _handle_abort_or_continue (Sprint 1 multi-review)
+
 ## v0.28.0 (2026-06-19)
 
 ### BREAKING CHANGE

{gitwise_cli-0.28.0 → gitwise_cli-0.29.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitwise-cli
-Version: 0.28.0
+Version: 0.29.0
 Summary: Python CLI for optimizing git workflows and Claude Code integration
 Project-URL: Homepage, https://github.com/drzioner/gitwise
 Project-URL: Repository, https://github.com/drzioner/gitwise

{gitwise_cli-0.28.0 → gitwise_cli-0.29.0}/gitwise/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.28.0"
+__version__ = "0.29.0"
 
 
 def get_version() -> str:

{gitwise_cli-0.28.0 → gitwise_cli-0.29.0}/gitwise/_cli_dispatch.py

@@ -255,6 +255,8 @@ def _run_merge(args: argparse.Namespace) -> int:
         no_ff=args.no_ff,
         dry_run=args.dry_run,
         yes=args.yes,
+        abort=args.abort,
+        continue_merge=args.continue_merge,
         as_json=args.json,
     )
 

{gitwise_cli-0.28.0 → gitwise_cli-0.29.0}/gitwise/_cli_parser.py

@@ -269,11 +269,20 @@ def build_parser() -> argparse.ArgumentParser:
     p.add_argument("--yes", "-y", action="store_true", help="skip confirmation")
 
     p = sub.add_parser("merge", help="merge/rebase with pre-flight checks", parents=[parent])
-    p.add_argument("branch", help="branch to merge/rebase from")
+    p.add_argument(
+        "branch", nargs="?", help="branch to merge/rebase from (omit with --abort/--continue)"
+    )
     p.add_argument("--rebase", action="store_true", help="rebase instead of merge")
     p.add_argument("--no-ff", action="store_true", help="force no-fast-forward")
     p.add_argument("--dry-run", action="store_true", help="show checks without merging")
     p.add_argument("--yes", "-y", action="store_true", help="skip confirmation")
+    p.add_argument("--abort", action="store_true", help="abort an in-progress merge or rebase")
+    p.add_argument(
+        "--continue",
+        dest="continue_merge",
+        action="store_true",
+        help="continue an in-progress merge or rebase after resolving conflicts",
+    )
 
     p = sub.add_parser(
         "conflicts", help="conflict detection and resolution helper", parents=[parent]

{gitwise_cli-0.28.0 → gitwise_cli-0.29.0}/gitwise/_i18n_data.json

@@ -251,6 +251,10 @@
     "es": "mensaje",
     "en": "msg"
   },
+  "commit_blocked_in_progress": {
+    "es": "No se puede commitear: hay una operación {state} en curso. Resuélvela o aborta primero.",
+    "en": "Cannot commit: a {state} operation is in progress. Resolve or abort it first."
+  },
   "commit_no_message": {
     "es": "usa -m para proveer un mensaje de commit",
     "en": "use -m to provide a commit message"
@@ -847,6 +851,26 @@
     "es": "merge",
     "en": "merge"
   },
+  "merge_aborted": {
+    "es": "Mezcla abortada",
+    "en": "Merge aborted"
+  },
+  "merge_abort_continue_mutually_exclusive": {
+    "es": "--abort y --continue son mutuamente excluyentes",
+    "en": "--abort and --continue are mutually exclusive"
+  },
+  "merge_branch_required": {
+    "es": "Especifica la rama a mezclar, o usa --abort/--continue para una operación pausada",
+    "en": "Specify a branch to merge, or use --abort/--continue for a paused operation"
+  },
+  "merge_continued": {
+    "es": "Mezcla continuada",
+    "en": "Merge continued"
+  },
+  "merge_no_in_progress": {
+    "es": "No hay mezcla/rebase en curso (estado actual: {state}). Usa {action} solo cuando gitwise detecta operación pausada.",
+    "en": "No merge/rebase in progress (current state: {state}). Use {action} only when gitwise detects a paused operation."
+  },
   "merge_ok": {
     "es": "Mezcla completada: {branch} → {into}",
     "en": "Merge completed: {branch} → {into}"
@@ -1667,6 +1691,10 @@
     "es": "Sugerencia: {message}",
     "en": "Suggestion: {message}"
   },
+  "suggest_blocked_in_progress": {
+    "es": "No se puede sugerir commit: hay una operación {state} en curso. Resuélvela o aborta primero.",
+    "en": "Cannot suggest commit: a {state} operation is in progress. Resolve or abort it first."
+  },
   "suggest_no_staged": {
     "es": "No hay archivos en área de preparación",
     "en": "No staged files"

{gitwise_cli-0.28.0 → gitwise_cli-0.29.0}/gitwise/commit.py

@@ -7,6 +7,7 @@ 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.in_progress import detect_in_progress, in_progress_hint
 from .utils.json_envelope import error_envelope, ok_envelope
 
 _CONVENTIONAL_RE = re.compile(
@@ -104,12 +105,34 @@ def run_commit(
     dry_run: bool = False,
     as_json: bool = False,
 ) -> int:
+    """Validate a conventional-commit message and create a GPG-signed commit.
+
+    Refuses with ``in_progress_<state>`` if an operation is paused. Enforces
+    the project's amend policy (no amending pushed or protected branches)
+    and GPG readiness before delegating to ``git commit``.
+    """
     root, err = require_root()
     if err:
         return err
     if root is None:
         return 1
 
+    in_progress = detect_in_progress(root)
+    if in_progress["state"] != "none":
+        hint = in_progress_hint(in_progress["state"])
+        blocked_msg = t("commit_blocked_in_progress", state=in_progress["state"])
+        if as_json:
+            print_json(
+                error_envelope(
+                    error=blocked_msg,
+                    code=f"in_progress_{in_progress['state']}",
+                    hint=hint,
+                )
+            )
+            return 1
+        error(blocked_msg, hint=hint)
+        return 1
+
     amend_policy_rc = _validate_amend_policy(amend=amend, root=root)
     if amend_policy_rc != 0:
         return amend_policy_rc

{gitwise_cli-0.28.0 → gitwise_cli-0.29.0}/gitwise/merge.py

@@ -14,6 +14,7 @@ from .output import (
     print_json,
     warn,
 )
+from .utils.in_progress import detect_in_progress
 from .utils.json_envelope import error_envelope, ok_envelope
 from .utils.parsing import to_int
 
@@ -143,21 +144,96 @@ def _report_merge_error(*, as_json: bool, err: str) -> int:
     return 1
 
 
+def _abort_or_continue_args(state: str, abort: bool) -> list[str]:
+    """Build the git argv for resolving a paused merge or rebase.
+
+    The subcommand must match the paused operation: `git merge --abort` errors
+    with "There is no merge to abort" when a rebase is paused, and vice versa.
+    Extracted as a pure function so the selection logic is testable without
+    driving a real paused rebase.
+    """
+    cmd = "rebase" if state == "rebase" else "merge"
+    flag = "--abort" if abort else "--continue"
+    return [cmd, flag]
+
+
+def _execute_abort_or_continue(*, root: Path, state: str, abort: bool) -> tuple[bool, str]:
+    """Run `git merge/rebase --abort` or `--continue`. Returns (success, error_msg)."""
+    result = git_run(_abort_or_continue_args(state=state, abort=abort), cwd=root, check=False)
+    if result.returncode == 0:
+        return True, ""
+    return False, result.stderr.strip() or result.stdout.strip()
+
+
+def _handle_abort_or_continue(*, root: Path, abort: bool, as_json: bool) -> int:
+    """Resolve a paused merge or rebase via `git merge/rebase --abort` / `--continue`."""
+    in_progress = detect_in_progress(root)
+    if in_progress["state"] not in ("merge", "rebase"):
+        available = (
+            "git merge/rebase --abort / --continue" if abort else "git merge/rebase --continue"
+        )
+        msg = t("merge_no_in_progress", action=available, state=in_progress["state"])
+        if as_json:
+            print_json(error_envelope(error=msg, code="merge_no_in_progress"))
+        else:
+            error(msg)
+        return 1
+    success, err_msg = _execute_abort_or_continue(
+        root=root, state=in_progress["state"], abort=abort
+    )
+    if not success:
+        return _report_merge_error(as_json=as_json, err=err_msg)
+    label_key = "merge_aborted" if abort else "merge_continued"
+    if as_json:
+        print_json(ok_envelope(action="abort" if abort else "continue"))
+    else:
+        ok(t(label_key))
+    return 0
+
+
 def run_merge(
-    branch: str,
+    branch: str | None = None,
     *,
     rebase: bool = False,
     no_ff: bool = False,
     dry_run: bool = False,
     yes: bool = False,
+    abort: bool = False,
+    continue_merge: bool = False,
     as_json: bool = False,
 ) -> int:
+    """Merge or rebase a branch with pre-flight checks, or resolve a paused op.
+
+    With ``--abort``/``--continue`` delegates to git's merge/rebase abort and
+    continue (subcommand chosen from the detected paused state). Otherwise
+    validates the target ref, warns on divergent branches, and asks for
+    confirmation before running ``git merge`` (or ``git rebase``).
+    """
     root, err = require_root()
     if err:
         return err
     if root is None:
         return 1
 
+    if abort and continue_merge:
+        msg = t("merge_abort_continue_mutually_exclusive")
+        if as_json:
+            print_json(error_envelope(error=msg, code="merge_invalid_args"))
+        else:
+            error(msg)
+        return 1
+
+    if abort or continue_merge:
+        return _handle_abort_or_continue(root=root, abort=abort, as_json=as_json)
+
+    if branch is None:
+        msg = t("merge_branch_required")
+        if as_json:
+            print_json(error_envelope(error=msg, code="merge_branch_required"))
+        else:
+            error(msg)
+        return 1
+
     cur = current_branch(root)
     target_err = _validate_merge_target(root=root, branch=branch, cur=cur)
     if target_err is not None:

{gitwise_cli-0.28.0 → gitwise_cli-0.29.0}/gitwise/status.py

@@ -16,6 +16,7 @@ from .output import (
     print_json,
     status,
 )
+from .utils.in_progress import detect_in_progress
 from .utils.parsing import parse_two_ints
 
 
@@ -32,6 +33,12 @@ def _range_commits(root: Path, rev_range: str) -> list[dict[str, str]]:
 
 
 def run_status(*, as_json: bool = False) -> int:
+    """Print a compact, agent-friendly view of the working-tree state.
+
+    Exposes branch, ahead/behind counts and commit lists, staged/unstaged/
+    untracked file counts, and an ``in_progress`` snapshot of any paused
+    merge/rebase/cherry-pick/revert/bisect operation.
+    """
     root, err = require_root()
     if err:
         return err
@@ -67,6 +74,8 @@ def run_status(*, as_json: bool = False) -> int:
             if behind:
                 behind_commits = _range_commits(root, "HEAD..@{u}")
 
+        in_progress = detect_in_progress(root)
+
     if as_json:
         print_json(
             {
@@ -78,6 +87,7 @@ def run_status(*, as_json: bool = False) -> int:
                 "behind": behind,
                 "ahead_commits": ahead_commits,
                 "behind_commits": behind_commits,
+                "in_progress": in_progress,
                 "staged": len(staged),
                 "unstaged": len(unstaged),
                 "untracked": len(untracked),

{gitwise_cli-0.28.0 → gitwise_cli-0.29.0}/gitwise/suggest.py

@@ -6,6 +6,7 @@ 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, status
+from .utils.in_progress import detect_in_progress, in_progress_hint
 from .utils.json_envelope import error_envelope, ok_envelope
 from .utils.parsing import stripped_non_empty_lines
 
@@ -110,12 +111,33 @@ def _print_suggest_human(
 
 
 def run_suggest(*, as_json: bool = False) -> int:
+    """Inspect staged files and propose a conventional-commit message.
+
+    Refuses with ``in_progress_<state>`` if a merge/rebase/cherry-pick/revert/
+    bisect is paused (so an agent never commits mid-operation).
+    """
     root, err = require_root()
     if err:
         return err
     if root is None:
         return 1
 
+    in_progress = detect_in_progress(root)
+    if in_progress["state"] != "none":
+        hint = in_progress_hint(in_progress["state"])
+        blocked_msg = t("suggest_blocked_in_progress", state=in_progress["state"])
+        if as_json:
+            print_json(
+                error_envelope(
+                    error=blocked_msg,
+                    code=f"in_progress_{in_progress['state']}",
+                    hint=hint,
+                )
+            )
+            return 1
+        error(blocked_msg, hint=hint)
+        return 1
+
     try:
         with status(t("status_analyzing_staged")):
             staged_files, staged_map = _collect_staged_files(root)

{gitwise_cli-0.28.0 → gitwise_cli-0.29.0}/gitwise/utils/git_output.py

@@ -26,6 +26,12 @@ def status_label(code: str) -> str:
 
 
 def parse_diffstat_entries(raw: str, *, default_status: str | None = None) -> list[dict[str, str]]:
+    """Parse `git diff --stat` lines into ``{path, changes[, status]}`` dicts.
+
+    Lines without ``|`` (summary/blank) are skipped. ``default_status`` is
+    attached when the caller knows the change kind (e.g. "staged") but the
+    diffstat output does not carry it.
+    """
     entries: list[dict[str, str]] = []
     for line in raw.splitlines():
         if "|" not in line:
@@ -43,6 +49,11 @@ def parse_diffstat_entries(raw: str, *, default_status: str | None = None) -> li
 
 
 def parse_name_status_entries(raw: str) -> list[dict[str, str]]:
+    """Parse `git diff --name-status` lines into ``{status, path[, code, score, old_path]}`` dicts.
+
+    Handles R/C (rename/copy) entries whose second column is the old path;
+    the score (e.g. ``R100``) is preserved when present.
+    """
     entries: list[dict[str, str]] = []
     for line in raw.splitlines():
         parts = line.split("\t")

gitwise_cli-0.29.0/gitwise/utils/in_progress.py

@@ -0,0 +1,112 @@
+"""Detect in-progress git operations (merge/rebase/cherry-pick/revert/bisect).
+
+Reads the same `.git/` artifacts git itself writes when an operation is
+paused on conflicts or steps. Resolves the real git-dir via
+`git rev-parse --git-dir` so worktrees (which keep their state under
+`.git/worktrees/<name>/`) are handled correctly.
+
+Marker reference (Verified against git source: builtin/am.c, sequencer.c,
+builtin/merge.c, git-rebase--merge.sh, gitglossary(7)):
+- MERGE_HEAD          → merge paused on conflicts
+- rebase-merge/       → interactive rebase in progress (also `rebase -m`)
+- rebase-apply/       → am/rebase--am in progress
+- CHERRY_PICK_HEAD    → cherry-pick paused on conflicts
+- REVERT_HEAD         → revert paused on conflicts
+- BISECT_LOG          → bisect session active
+- sequencer/todo      → multi-step cherry-pick/revert queue
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Literal, TypedDict
+
+from ..git import run as git_run
+
+InProgressState = Literal["none", "merge", "rebase", "cherry-pick", "revert", "bisect"]
+
+
+class InProgressInfo(TypedDict):
+    """Snapshot of any paused git operation in the working tree."""
+
+    state: InProgressState
+    ref: str | None
+
+
+def _resolve_git_dir(root: Path) -> Path | None:
+    """Return the real git-dir for `root`, or None if git itself is unavailable.
+
+    Uses `git rev-parse --git-dir` so worktrees resolve to their per-worktree
+    state directory rather than the shared common dir.
+    """
+    result = git_run(["rev-parse", "--git-dir"], cwd=root, check=False)
+    if result.returncode != 0:
+        return None
+    raw = result.stdout.strip()
+    if not raw:
+        return None
+    # Use os.path.realpath (not Path.resolve()) per AGENTS.md: Path.resolve()
+    # can fail on broken symlinks, which matters inside .git/worktrees/.
+    candidate = Path(raw)
+    git_dir = Path(os.path.realpath(candidate if candidate.is_absolute() else root / raw))
+    return git_dir if git_dir.is_dir() else None
+
+
+def _read_head_ref(git_dir: Path, marker: str) -> str | None:
+    """Return the SHA stored in `<git_dir>/<marker>`, or None if absent/empty."""
+    marker_path = git_dir / marker
+    if not marker_path.is_file():
+        return None
+    content = marker_path.read_text(encoding="utf-8", errors="replace").strip()
+    return content or None
+
+
+def detect_in_progress(root: Path) -> InProgressInfo:
+    """Inspect `root` for any paused git operation.
+
+    Returns `{"state": "none", "ref": None}` when the working tree is clean
+    of in-progress operations. Priority order: merge > rebase > cherry-pick >
+    revert > bisect — matches the order git itself applies when multiple
+    state dirs co-exist (which is rare but possible if a user aborts one op
+    into another).
+    """
+    git_dir = _resolve_git_dir(root)
+    if git_dir is None:
+        return InProgressInfo(state="none", ref=None)
+
+    merge_ref = _read_head_ref(git_dir, "MERGE_HEAD")
+    if merge_ref is not None:
+        return InProgressInfo(state="merge", ref=merge_ref)
+
+    if (git_dir / "rebase-merge").is_dir() or (git_dir / "rebase-apply").is_dir():
+        rebase_ref = _read_head_ref(git_dir / "rebase-merge", "head-name")
+        return InProgressInfo(state="rebase", ref=rebase_ref)
+
+    cherry_ref = _read_head_ref(git_dir, "CHERRY_PICK_HEAD")
+    if cherry_ref is not None:
+        return InProgressInfo(state="cherry-pick", ref=cherry_ref)
+
+    revert_ref = _read_head_ref(git_dir, "REVERT_HEAD")
+    if revert_ref is not None:
+        return InProgressInfo(state="revert", ref=revert_ref)
+
+    if (git_dir / "BISECT_LOG").is_file():
+        return InProgressInfo(state="bisect", ref=None)
+
+    return InProgressInfo(state="none", ref=None)
+
+
+_HINT_COMMANDS: dict[InProgressState, str] = {
+    "none": "",
+    "merge": "git merge --continue  # or  git merge --abort",
+    "rebase": "git rebase --continue  # or  git rebase --abort",
+    "cherry-pick": "git cherry-pick --continue  # or  git cherry-pick --abort",
+    "revert": "git revert --continue  # or  git revert --abort",
+    "bisect": "git bisect reset",
+}
+
+
+def in_progress_hint(state: InProgressState) -> str:
+    """Return the canonical recovery command for a paused operation state."""
+    return _HINT_COMMANDS.get(state, "")

{gitwise_cli-0.28.0 → gitwise_cli-0.29.0}/gitwise/utils/json_envelope.py

@@ -9,6 +9,11 @@ def ok_envelope(
     version: int = 2,
     **extra: object,
 ) -> dict[str, object]:
+    """Build a success envelope: ``{v, ok: true, ...payload, ...extra}``.
+
+    ``payload`` and ``extra`` are flattened into the top-level dict so callers
+    can pass command-specific fields (e.g. ``message=``, ``merged=``) directly.
+    """
     data: dict[str, object] = {}
     if payload is not None:
         data.update(payload)
@@ -27,6 +32,12 @@ def error_envelope(
     version: int = 2,
     **extra: object,
 ) -> dict[str, object]:
+    """Build an error envelope: ``{v, ok: false, error, errors: [{code, message, hint?}]}``.
+
+    ``code`` defaults to ``"error"``; pass a stable machine-readable code
+    (e.g. ``"in_progress_merge"``) so agents can branch on it. ``hint`` is
+    surfaced both in ``errors[0].hint`` and (by callers) in human output.
+    """
     data: dict[str, object] = {}
     if payload is not None:
         data.update(payload)
@@ -50,6 +61,12 @@ def passthrough_envelope(
     version: int = 2,
     **extra: object,
 ) -> dict[str, object]:
+    """Build a versioned envelope without an ``ok`` field.
+
+    Used by commands whose payload already carries the success/failure signal
+    (e.g. ``health`` returns its own status), so forcing ``ok: true/false``
+    would duplicate or contradict it.
+    """
     data: dict[str, object] = {}
     if payload is not None:
         data.update(payload)

{gitwise_cli-0.28.0 → gitwise_cli-0.29.0}/gitwise/utils/parsing.py

@@ -2,14 +2,17 @@
 
 
 def non_empty_lines(text: str) -> list[str]:
+    """Split ``text`` into lines, dropping blanks. Preserves leading/trailing whitespace."""
     return [line for line in text.splitlines() if line.strip()]
 
 
 def stripped_non_empty_lines(text: str) -> list[str]:
+    """Split ``text`` into lines, dropping blanks and stripping each survivor."""
     return [line.strip() for line in text.splitlines() if line.strip()]
 
 
 def to_int(value: object, *, default: int = 0) -> int:
+    """Coerce ``value`` to int, returning ``default`` on parse failure (no exception)."""
     if isinstance(value, int):
         return value
     try:
@@ -19,6 +22,7 @@ def to_int(value: object, *, default: int = 0) -> int:
 
 
 def parse_two_ints(text: str) -> tuple[int, int] | None:
+    """Parse two whitespace-separated ints (e.g. git ahead/behind counts). None on failure."""
     parts = text.strip().split()
     if len(parts) != 2:
         return None
@@ -29,6 +33,7 @@ def parse_two_ints(text: str) -> tuple[int, int] | None:
 
 
 def dict_list(value: object) -> list[dict[str, object]]:
+    """Return ``value`` if it is a list of dicts, else ``[]``. Tolerates non-list input."""
     if not isinstance(value, list):
         return []
     return [item for item in value if isinstance(item, dict)]

{gitwise_cli-0.28.0 → gitwise_cli-0.29.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "gitwise-cli"
-version = "0.28.0"
+version = "0.29.0"
 description = "Python CLI for optimizing git workflows and Claude Code integration"
 readme = "README.md"
 license = "MIT"

{gitwise_cli-0.28.0 → gitwise_cli-0.29.0}/share/schemas/v1/input/merge.json

@@ -34,7 +34,7 @@
     },
     "branch": {
       "type": "string",
-      "description": "branch to merge/rebase from"
+      "description": "branch to merge/rebase from (omit with --abort/--continue)"
     },
     "rebase": {
       "type": "boolean",
@@ -55,9 +55,16 @@
       "type": "boolean",
       "description": "skip confirmation",
       "default": false
+    },
+    "abort": {
+      "type": "boolean",
+      "description": "abort an in-progress merge or rebase",
+      "default": false
+    },
+    "continue_merge": {
+      "type": "boolean",
+      "description": "continue an in-progress merge or rebase after resolving conflicts",
+      "default": false
     }
-  },
-  "required": [
-    "branch"
-  ]
+  }
 }