gitpush-tool 0.4.2__tar.gz → 0.4.3__tar.gz

{gitpush_tool-0.4.2 → gitpush_tool-0.4.3}/LONG_DESCRIPTION.md

@@ -9,7 +9,9 @@ A supercharged Git CLI and safety tool that simplifies repository creation and p
 
 ## ✨ Features
 
+- **Smart Sync Engine (`gitpush sync`):** Intelligent single-command replacement for `git pull → git add → git commit → git push`. Automatically detects repository state (clean, dirty, ahead, behind, diverged) and safely synchronizes with remote.
 - **Decision-Support Status Dashboard (`gitpush status`):** Actionable repository overview showing worktree breakdown, commit sync, intelligent next-step recommendations, and a 0-100 Repo Health score.
+- **Interactive Undo Engine (`gitpush undo`):** Reversible and safe rollback for commits and pushes with detailed previews.
 - **Pre-Push Safety & Diffstat Preview:** See changed files, line additions/deletions (`+X, -Y`), ahead/behind status, and pending commits before pushing.
 - **Dangerous Git Operation Guard:** Analyzes and protects against risky actions (`reset --hard`, force pushes, deleting unmerged branches, dirty `git clean`, detached HEADs).
 - **Protected Branch Safeguard:** Automatically detects and alerts when pushing or force-pushing to `main`, `master`, `prod`, `release`, or `dev`.

{gitpush_tool-0.4.2/gitpush_tool.egg-info → gitpush_tool-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitpush-tool
-Version: 0.4.2
+Version: 0.4.3
 Summary: Supercharged Git push tool with automatic GitHub repo creation and pushing
 Home-page: https://github.com/inevitablegs/gitpush
 Author: Ganesh Sonawane
@@ -38,7 +38,9 @@ A supercharged Git CLI and safety tool that simplifies repository creation and p
 
 ## ✨ Features
 
+- **Smart Sync Engine (`gitpush sync`):** Intelligent single-command replacement for `git pull → git add → git commit → git push`. Automatically detects repository state (clean, dirty, ahead, behind, diverged) and safely synchronizes with remote.
 - **Decision-Support Status Dashboard (`gitpush status`):** Actionable repository overview showing worktree breakdown, commit sync, intelligent next-step recommendations, and a 0-100 Repo Health score.
+- **Interactive Undo Engine (`gitpush undo`):** Reversible and safe rollback for commits and pushes with detailed previews.
 - **Pre-Push Safety & Diffstat Preview:** See changed files, line additions/deletions (`+X, -Y`), ahead/behind status, and pending commits before pushing.
 - **Dangerous Git Operation Guard:** Analyzes and protects against risky actions (`reset --hard`, force pushes, deleting unmerged branches, dirty `git clean`, detached HEADs).
 - **Protected Branch Safeguard:** Automatically detects and alerts when pushing or force-pushing to `main`, `master`, `prod`, `release`, or `dev`.

{gitpush_tool-0.4.2 → gitpush_tool-0.4.3}/README.md

@@ -9,7 +9,9 @@ A supercharged Git CLI and safety tool that simplifies repository creation and p
 
 ## ✨ Features
 
+- **Smart Sync Engine (`gitpush sync`):** Intelligent single-command replacement for `git pull → git add → git commit → git push`. Automatically detects repository state (clean, dirty, ahead, behind, diverged) and safely synchronizes with remote.
 - **Decision-Support Status Dashboard (`gitpush status`):** Actionable repository overview showing worktree breakdown, commit sync, intelligent next-step recommendations, and a 0-100 Repo Health score.
+- **Interactive Undo Engine (`gitpush undo`):** Reversible and safe rollback for commits and pushes with detailed previews.
 - **Pre-Push Safety & Diffstat Preview:** See changed files, line additions/deletions (`+X, -Y`), ahead/behind status, and pending commits before pushing.
 - **Dangerous Git Operation Guard:** Analyzes and protects against risky actions (`reset --hard`, force pushes, deleting unmerged branches, dirty `git clean`, detached HEADs).
 - **Protected Branch Safeguard:** Automatically detects and alerts when pushing or force-pushing to `main`, `master`, `prod`, `release`, or `dev`.
@@ -20,6 +22,50 @@ A supercharged Git CLI and safety tool that simplifies repository creation and p
 
 ---
 
+## 🔄 Smart Sync Engine (`gitpush sync`)
+
+Instead of running four separate commands every time:
+```bash
+git pull
+git add .
+git commit -m "..."
+git push
+```
+
+Run **`gitpush sync`** (or `gitpush-sync`). GitPush detects your exact state and handles everything intelligently:
+
+### Scenario A: Local Ahead
+```text
+Local:  3 commits ahead
+Remote: 0 commits ahead
+
+→ Safe to push
+```
+Prompts for push confirmation, or auto-pushes with `gitpush sync -y`.
+
+### Scenario B: Branch Diverged
+```text
+Local:  2 commits ahead
+Remote: 3 commits ahead
+
+⚠ Branch has diverged.
+
+Options:
+  1. Rebase — replay your commits on top of remote (clean history)
+  2. Merge  — merge remote into local (preserves history)
+  3. Abort  — cancel sync
+```
+
+### Scenario C: Modified Files Detected
+```text
+Working Tree: 3 file(s) modified (+45, -8)
+
+Commit before sync? [y/N]: y
+Commit message (Enter for auto): Add user authentication
+```
+
+---
+
 ## 📦 Installation
 
 ```bash
@@ -145,6 +191,12 @@ Continue? [y/N]:
 
 | Command | Description |
 |---|---|
+| `gitpush sync` | Intelligent one-command sync (pull, commit dirty files, rebase/merge, push). |
+| `gitpush sync -y` | Auto-confirms prompts and syncs immediately. |
+| `gitpush sync -m "Msg"` | Sets custom commit message for modified files during sync. |
+| `gitpush sync --rebase` | Prefers rebase automatically when branch has diverged. |
+| `gitpush undo` | Interactive undo engine for commits and pushed history. |
+| `gitpush status` | Decision-support status dashboard with recommendations. |
 | `gitpush "Commit message"` | Stages all changes, previews diffs, commits, and pushes. |
 | `gitpush` | Pushes staged/unpushed changes with safety preview. |
 | `gitpush -y` | Pushes immediately without confirmation prompt. |

gitpush_tool-0.4.3/gitpush/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.3"

{gitpush_tool-0.4.2 → gitpush_tool-0.4.3}/gitpush/cli.py

@@ -47,6 +47,7 @@ from .safety import (
 
 from .status import format_status_dashboard
 from .undo import run_undo_flow
+from .sync import run_sync_flow
 
 
 # --- GitHub CLI Installation Orchestrator and Helpers ---
@@ -704,6 +705,29 @@ def run():
         clean_args = [a for a in guard_args if a not in ("-y", "--yes")]
         sys.exit(handle_guard_command(clean_args, auto_confirm=auto_confirm))
 
+    # Handle sync subcommand upfront if detected
+    if len(sys.argv) > 1 and sys.argv[1].lower() == "sync":
+        sync_args = sys.argv[2:]
+        sync_auto = "-y" in sync_args or "--yes" in sync_args
+        sync_rebase = "--rebase" in sync_args
+        sync_message = None
+        # Parse -m / --message
+        for i, arg in enumerate(sync_args):
+            if arg in ("-m", "--message") and i + 1 < len(sync_args):
+                sync_message = sync_args[i + 1]
+                break
+        sync_remote = "origin"
+        for i, arg in enumerate(sync_args):
+            if arg in ("-r", "--remote") and i + 1 < len(sync_args):
+                sync_remote = sync_args[i + 1]
+                break
+        sys.exit(run_sync_flow(
+            auto_confirm=sync_auto,
+            commit_message=sync_message,
+            prefer_rebase=sync_rebase,
+            remote=sync_remote,
+        ))
+
     parser = argparse.ArgumentParser(
         description="🚀 Supercharged Git push tool with decision-support status, undo engine, and safety guards",
         formatter_class=argparse.RawDescriptionHelpFormatter,
@@ -712,6 +736,10 @@ def run():
   Undo last commit:      gitpush undo commit
   Undo push / rollback:  gitpush undo push
   Decision status:       gitpush status
+  Smart sync:            gitpush sync
+  Sync (auto-confirm):   gitpush sync -y
+  Sync with message:     gitpush sync -m "My changes"
+  Sync (prefer rebase):  gitpush sync --rebase
   Standard push:         gitpush "My new feature"
   Push without prompt:   gitpush "My new feature" -y
   Dry run preview:       gitpush "My new feature" --dry-run

gitpush_tool-0.4.3/gitpush/sync.py

@@ -0,0 +1,524 @@
+"""
+GitPush Sync Engine
+Intelligent single-command replacement for the pull → add → commit → push cycle.
+Detects repository state and acts accordingly with interactive prompts.
+"""
+
+import sys
+import subprocess
+from typing import Optional, List
+
+from .safety import (
+    is_git_repo,
+    get_repo_name,
+    get_repo_root,
+    get_current_branch,
+    is_detached_head,
+    is_protected_branch,
+    get_ahead_behind,
+    get_diffstat_summary,
+    get_pending_commits,
+    run_git,
+    colorize,
+    Style,
+    prompt_confirm,
+)
+
+
+# ──────────────────────────────────────────────────────────────────
+#  Helpers
+# ──────────────────────────────────────────────────────────────────
+
+def _fetch(remote: str = "origin", cwd: Optional[str] = None) -> bool:
+    """Fetch from remote silently. Returns True on success."""
+    print(f"\n{colorize('🔄 Fetching from remote...', Style.DIM)}")
+    res = run_git(["fetch", remote], check=False, cwd=cwd)
+    if res.returncode != 0:
+        err = res.stderr.strip() if res.stderr else "unknown error"
+        print(colorize(f"   ⚠️  Fetch failed: {err}", Style.YELLOW))
+        return False
+    return True
+
+
+def _get_tracking_info(branch: str, cwd: Optional[str] = None) -> Optional[str]:
+    """Return the upstream tracking ref (e.g. 'origin/main') or None."""
+    res = run_git(["rev-parse", "--abbrev-ref", "--symbolic-full-name", f"{branch}@{{u}}"], cwd=cwd)
+    if res.returncode == 0 and res.stdout.strip():
+        return res.stdout.strip()
+    return None
+
+
+def _has_remote(remote: str = "origin", cwd: Optional[str] = None) -> bool:
+    """Check if the named remote exists."""
+    res = run_git(["remote", "get-url", remote], cwd=cwd)
+    return res.returncode == 0
+
+
+def _set_upstream_and_push(remote: str, branch: str, cwd: Optional[str] = None) -> bool:
+    """Push current branch and set upstream tracking."""
+    print(f"🚀 Pushing and setting upstream → {remote}/{branch}")
+    try:
+        subprocess.run(
+            ["git", "push", "-u", remote, branch],
+            check=True,
+            cwd=cwd
+        )
+        print(colorize("✅ Upstream set and pushed successfully.", Style.GREEN))
+        return True
+    except subprocess.CalledProcessError as e:
+        err = e.stderr.decode(errors="ignore").strip() if e.stderr else str(e)
+        print(f"❌ Push failed: {err}", file=sys.stderr)
+        return False
+
+
+def _auto_generate_message(diff_summary: dict) -> str:
+    """Generate a short commit message from the diff summary."""
+    total = diff_summary["modified_count"]
+    adds = diff_summary["total_additions"]
+    dels = diff_summary["total_deletions"]
+    parts = []
+    if total == 1:
+        parts.append(f"Update {diff_summary['files'][0].path}")
+    else:
+        parts.append(f"Update {total} files")
+    parts.append(f"(+{adds}, -{dels})")
+    return " ".join(parts)
+
+
+def _stage_and_commit(message: str, cwd: Optional[str] = None) -> bool:
+    """Stage all changes and commit."""
+    try:
+        subprocess.run(["git", "add", "."], check=True, capture_output=True, cwd=cwd)
+        subprocess.run(
+            ["git", "commit", "-m", message, "--allow-empty-message"],
+            check=True,
+            capture_output=True,
+            cwd=cwd
+        )
+        return True
+    except subprocess.CalledProcessError as e:
+        err = e.stderr.decode(errors="ignore").strip() if e.stderr else str(e)
+        if "nothing to commit" in err:
+            print(colorize("ℹ️  Nothing to commit.", Style.DIM))
+            return True
+        print(f"❌ Commit failed: {err}", file=sys.stderr)
+        return False
+
+
+def _pull_ff(remote: str, branch: str, cwd: Optional[str] = None) -> bool:
+    """Fast-forward pull."""
+    print(f"⬇️  Pulling {remote}/{branch} (fast-forward)...")
+    try:
+        subprocess.run(
+            ["git", "pull", "--ff-only", remote, branch],
+            check=True,
+            cwd=cwd
+        )
+        print(colorize("✅ Fast-forward pull complete.", Style.GREEN))
+        return True
+    except subprocess.CalledProcessError:
+        print(colorize("⚠️  Fast-forward failed (branches may have diverged).", Style.YELLOW))
+        return False
+
+
+def _pull_merge(remote: str, branch: str, cwd: Optional[str] = None) -> bool:
+    """Pull with merge strategy."""
+    print(f"⬇️  Pulling {remote}/{branch} (merge)...")
+    try:
+        result = subprocess.run(
+            ["git", "pull", remote, branch],
+            capture_output=True, text=True,
+            cwd=cwd
+        )
+        if result.returncode != 0:
+            err = result.stderr.strip() if result.stderr else result.stdout.strip()
+            if "CONFLICT" in err or "CONFLICT" in (result.stdout or ""):
+                print(colorize("❗ Merge conflicts detected. Resolve them and run `gitpush sync` again.", Style.RED))
+                _show_conflicts(cwd=cwd)
+                return False
+            print(f"❌ Merge pull failed: {err}", file=sys.stderr)
+            return False
+
+        if "CONFLICT" in (result.stdout or ""):
+            print(colorize("❗ Merge conflicts detected. Resolve them and run `gitpush sync` again.", Style.RED))
+            _show_conflicts(cwd=cwd)
+            return False
+
+        print(colorize("✅ Merge pull complete.", Style.GREEN))
+        return True
+    except subprocess.CalledProcessError as e:
+        err = e.stderr.decode(errors="ignore").strip() if e.stderr else str(e)
+        print(f"❌ Pull failed: {err}", file=sys.stderr)
+        return False
+
+
+def _pull_rebase(remote: str, branch: str, cwd: Optional[str] = None) -> bool:
+    """Pull with rebase strategy."""
+    print(f"🔁 Rebasing onto {remote}/{branch}...")
+    try:
+        result = subprocess.run(
+            ["git", "pull", "--rebase", remote, branch],
+            capture_output=True, text=True,
+            cwd=cwd
+        )
+        if result.returncode != 0:
+            err = result.stderr.strip() if result.stderr else result.stdout.strip()
+            if "CONFLICT" in err or "CONFLICT" in (result.stdout or ""):
+                print(colorize("❗ Rebase conflicts detected.", Style.RED))
+                print("   Resolve conflicts, then run:")
+                print(colorize("     git rebase --continue", Style.CYAN))
+                print("   Or abort with:")
+                print(colorize("     git rebase --abort", Style.CYAN))
+                return False
+            print(f"❌ Rebase failed: {err}", file=sys.stderr)
+            return False
+        print(colorize("✅ Rebase complete.", Style.GREEN))
+        return True
+    except subprocess.CalledProcessError as e:
+        err = e.stderr.decode(errors="ignore").strip() if e.stderr else str(e)
+        print(f"❌ Rebase failed: {err}", file=sys.stderr)
+        return False
+
+
+def _push(remote: str, branch: str, cwd: Optional[str] = None) -> bool:
+    """Standard push."""
+    print(f"🚀 Pushing to {remote}/{branch}...")
+    try:
+        subprocess.run(["git", "push", remote, branch], check=True, cwd=cwd)
+        print(colorize("✅ Push complete.", Style.GREEN))
+        return True
+    except subprocess.CalledProcessError as e:
+        err = e.stderr.decode(errors="ignore").strip() if e.stderr else str(e)
+        print(f"❌ Push failed: {err}", file=sys.stderr)
+        return False
+
+
+def _show_conflicts(cwd: Optional[str] = None):
+    """Print conflicted files."""
+    res = run_git(["diff", "--name-only", "--diff-filter=U"], cwd=cwd)
+    if res.returncode == 0 and res.stdout.strip():
+        files = res.stdout.strip().splitlines()
+        print(colorize(f"\n   Conflicted files ({len(files)}):", Style.BOLD))
+        for f in files[:10]:
+            print(f"     • {f}")
+        if len(files) > 10:
+            print(f"     • ... and {len(files) - 10} more")
+
+
+def _prompt_choice(prompt_text: str, options: List[str]) -> int:
+    """
+    Display numbered options and prompt user to choose.
+    Returns 0-based index, or -1 on cancel.
+    """
+    print()
+    for i, opt in enumerate(options, 1):
+        print(f"  {colorize(str(i), Style.BOLD, Style.CYAN)}. {opt}")
+    print()
+    try:
+        sys.stdout.write(colorize(prompt_text, Style.BOLD))
+        sys.stdout.flush()
+        choice = input().strip()
+        if choice.isdigit():
+            idx = int(choice) - 1
+            if 0 <= idx < len(options):
+                return idx
+        return -1
+    except (EOFError, KeyboardInterrupt):
+        sys.stdout.write("\n")
+        return -1
+
+
+# ──────────────────────────────────────────────────────────────────
+#  Sync Dashboard
+# ──────────────────────────────────────────────────────────────────
+
+def _print_sync_header(branch: str, remote: str, behind: int, ahead: int, diff_summary: dict, cwd: Optional[str] = None):
+    """Print a compact sync status dashboard."""
+    repo = get_repo_name(cwd)
+
+    print()
+    print(colorize("═══════════════════════════════════════════════════════════════", Style.CYAN))
+    print(colorize(" 🔄 GITPUSH SYNC", Style.BOLD, Style.CYAN))
+    print(colorize("═══════════════════════════════════════════════════════════════", Style.CYAN))
+    print()
+
+    print(f"  {colorize('Repository:', Style.BOLD)}  {colorize(repo, Style.GREEN)}")
+
+    branch_display = branch
+    if is_protected_branch(branch):
+        branch_display = colorize(f"{branch} ⚠️ [PROTECTED]", Style.BOLD, Style.YELLOW)
+    else:
+        branch_display = colorize(branch, Style.CYAN)
+    print(f"  {colorize('Branch:', Style.BOLD)}      {branch_display}  ↔  {colorize(f'{remote}/{branch}', Style.DIM)}")
+
+    # Sync indicators
+    local_label = f"{ahead} commit(s) ahead" if ahead > 0 else "0 commits ahead"
+    remote_label = f"{behind} commit(s) ahead" if behind > 0 else "0 commits ahead"
+
+    if ahead > 0:
+        local_styled = colorize(local_label, Style.GREEN)
+    else:
+        local_styled = colorize(local_label, Style.DIM)
+
+    if behind > 0:
+        remote_styled = colorize(remote_label, Style.YELLOW)
+    else:
+        remote_styled = colorize(remote_label, Style.DIM)
+
+    print(f"  {colorize('Local:', Style.BOLD)}       {local_styled}")
+    print(f"  {colorize('Remote:', Style.BOLD)}      {remote_styled}")
+
+    # Working tree
+    if diff_summary["has_changes"]:
+        n_files = diff_summary["modified_count"]
+        adds = colorize(f"+{diff_summary['total_additions']}", Style.GREEN)
+        dels = colorize(f"-{diff_summary['total_deletions']}", Style.RED)
+        print(f"  {colorize('Working Tree:', Style.BOLD)} {colorize(f'{n_files} file(s) modified', Style.YELLOW)} ({adds}, {dels})")
+    else:
+        print(f"  {colorize('Working Tree:', Style.BOLD)} {colorize('Clean', Style.GREEN)}")
+
+    print()
+
+
+def _print_sync_footer(success: bool):
+    """Print the sync result footer."""
+    if success:
+        print(colorize("═══════════════════════════════════════════════════════════════", Style.GREEN))
+        print(colorize(" ✅ Sync complete!", Style.BOLD, Style.GREEN))
+        print(colorize("═══════════════════════════════════════════════════════════════", Style.GREEN))
+    else:
+        print(colorize("═══════════════════════════════════════════════════════════════", Style.RED))
+        print(colorize(" ❌ Sync incomplete — see errors above.", Style.BOLD, Style.RED))
+        print(colorize("═══════════════════════════════════════════════════════════════", Style.RED))
+    print()
+
+
+# ──────────────────────────────────────────────────────────────────
+#  Main Sync Flow
+# ──────────────────────────────────────────────────────────────────
+
+def run_sync_flow(
+    auto_confirm: bool = False,
+    commit_message: Optional[str] = None,
+    prefer_rebase: bool = False,
+    remote: str = "origin",
+    cwd: Optional[str] = None,
+) -> int:
+    """
+    Run the full sync flow:
+      1. Validate repo state
+      2. Fetch remote
+      3. Detect scenario (clean, dirty, ahead, behind, diverged, no upstream)
+      4. Execute appropriate actions with interactive prompts
+      5. Report result
+
+    Returns exit code: 0 for success, 1 for failure/abort.
+    """
+
+    # ── 1. Validate ──────────────────────────────────────────────
+    if not is_git_repo(cwd):
+        print("❌ Not a Git repository (or any of the parent directories).", file=sys.stderr)
+        print("➡️  Run 'gitpush --init' or 'git init' first.", file=sys.stderr)
+        return 1
+
+    if is_detached_head(cwd):
+        print(colorize("❌ Cannot sync in detached HEAD state.", Style.RED))
+        print("➡️  Check out a branch first: git checkout <branch>")
+        return 1
+
+    branch = get_current_branch(cwd)
+
+    # Protected branch warning
+    if is_protected_branch(branch):
+        print(colorize(f"\n⚠️  You are syncing on protected branch '{branch}'.", Style.BOLD, Style.YELLOW))
+        if not auto_confirm:
+            if not prompt_confirm("Continue? [y/N]: "):
+                print(colorize("🛑 Sync cancelled.", Style.YELLOW))
+                return 0
+
+    # ── 2. Check remote & upstream ───────────────────────────────
+    if not _has_remote(remote, cwd=cwd):
+        print(colorize(f"❌ Remote '{remote}' does not exist.", Style.RED))
+        print(f"➡️  Add one with: git remote add {remote} <url>")
+        return 1
+
+    tracking = _get_tracking_info(branch, cwd=cwd)
+    no_upstream = tracking is None
+
+    # ── 3. Fetch ─────────────────────────────────────────────────
+    if not no_upstream:
+        _fetch(remote, cwd=cwd)
+
+    # ── 4. Detect state ──────────────────────────────────────────
+    diff_summary = get_diffstat_summary(cwd=cwd)
+    has_dirty = diff_summary["has_changes"]
+
+    if no_upstream:
+        behind, ahead = 0, 0
+    else:
+        behind, ahead = get_ahead_behind(remote, branch, cwd=cwd)
+
+    # Print dashboard
+    _print_sync_header(branch, remote, behind, ahead, diff_summary, cwd=cwd)
+
+    # ── 5. Handle no-upstream scenario ───────────────────────────
+    if no_upstream:
+        print(colorize("ℹ️  No upstream tracking branch configured.", Style.YELLOW))
+
+        # If dirty, commit first
+        if has_dirty:
+            print(colorize("   Modified files detected.", Style.YELLOW))
+            if not auto_confirm:
+                if not prompt_confirm("   Commit before pushing? [y/N]: "):
+                    print(colorize("🛑 Sync cancelled.", Style.YELLOW))
+                    return 0
+            msg = commit_message or _auto_generate_message(diff_summary)
+            print(f"\n📦 Committing: {colorize(repr(msg), Style.WHITE)}")
+            if not _stage_and_commit(msg, cwd=cwd):
+                _print_sync_footer(False)
+                return 1
+
+        if not auto_confirm:
+            if not prompt_confirm(f"   Push and set upstream to {remote}/{branch}? [y/N]: "):
+                print(colorize("🛑 Sync cancelled.", Style.YELLOW))
+                return 0
+
+        success = _set_upstream_and_push(remote, branch, cwd=cwd)
+        _print_sync_footer(success)
+        return 0 if success else 1
+
+    # ── 6. Handle dirty working tree ─────────────────────────────
+    if has_dirty:
+        print(colorize("📝 Modified files detected.", Style.YELLOW))
+        n_files = diff_summary["modified_count"]
+        # Show first few changed files
+        for f in diff_summary["files"][:8]:
+            status_icon = {"M": "~", "A": "+", "D": "-", "??": "?"}.get(f.status, "·")
+            print(f"     {colorize(status_icon, Style.CYAN)} {f.path}")
+        if n_files > 8:
+            print(colorize(f"     ... and {n_files - 8} more", Style.DIM))
+        print()
+
+        if not auto_confirm:
+            if not prompt_confirm("   Commit before sync? [y/N]: "):
+                print(colorize("⚠️  Skipping commit. Only existing commits will be synced.", Style.YELLOW))
+            else:
+                msg = commit_message
+                if not msg:
+                    try:
+                        sys.stdout.write(colorize("   Commit message (Enter for auto): ", Style.BOLD))
+                        sys.stdout.flush()
+                        msg = input().strip()
+                    except (EOFError, KeyboardInterrupt):
+                        print()
+                        msg = ""
+                if not msg:
+                    msg = _auto_generate_message(diff_summary)
+                print(f"\n📦 Committing: {colorize(repr(msg), Style.WHITE)}")
+                if not _stage_and_commit(msg, cwd=cwd):
+                    _print_sync_footer(False)
+                    return 1
+
+                # Refresh ahead count after commit
+                _, ahead = get_ahead_behind(remote, branch, cwd=cwd)
+        else:
+            # Auto mode: commit with provided or auto message
+            msg = commit_message or _auto_generate_message(diff_summary)
+            print(f"\n📦 Committing: {colorize(repr(msg), Style.WHITE)}")
+            if not _stage_and_commit(msg, cwd=cwd):
+                _print_sync_footer(False)
+                return 1
+            _, ahead = get_ahead_behind(remote, branch, cwd=cwd)
+
+    # Re-check counts after potential commit
+    behind, ahead = get_ahead_behind(remote, branch, cwd=cwd)
+
+    # ── 7. Scenario: Synced ──────────────────────────────────────
+    if behind == 0 and ahead == 0:
+        print(colorize("✅ Already in sync — nothing to do.", Style.GREEN))
+        _print_sync_footer(True)
+        return 0
+
+    # ── 8. Scenario: Local ahead only → push ─────────────────────
+    if ahead > 0 and behind == 0:
+        print(colorize(f"→ Safe to push ({ahead} commit(s) ahead, remote is up to date).", Style.GREEN))
+        print()
+
+        # Show pending commits
+        pending = get_pending_commits(remote, branch, cwd=cwd)
+        if pending:
+            print(colorize(f"  Commits to push ({len(pending)}):", Style.BOLD))
+            for sha, subj in pending[:5]:
+                print(f"    • {colorize(sha, Style.YELLOW)} {subj}")
+            if len(pending) > 5:
+                print(colorize(f"    • ... and {len(pending) - 5} more", Style.DIM))
+            print()
+
+        if not auto_confirm:
+            if not prompt_confirm("   Push now? [Y/n]: "):
+                print(colorize("🛑 Push cancelled.", Style.YELLOW))
+                return 0
+
+        success = _push(remote, branch, cwd=cwd)
+        _print_sync_footer(success)
+        return 0 if success else 1
+
+    # ── 9. Scenario: Remote ahead only → pull ────────────────────
+    if behind > 0 and ahead == 0:
+        print(colorize(f"→ Remote is {behind} commit(s) ahead. Pulling...", Style.YELLOW))
+        print()
+
+        success = _pull_ff(remote, branch, cwd=cwd)
+        if not success:
+            # Fast-forward failed, try regular pull
+            success = _pull_merge(remote, branch, cwd=cwd)
+
+        _print_sync_footer(success)
+        return 0 if success else 1
+
+    # ── 10. Scenario: Diverged ───────────────────────────────────
+    if behind > 0 and ahead > 0:
+        print(colorize(f"⚠️  Branch has diverged.", Style.BOLD, Style.YELLOW))
+        print(f"     Local:  {colorize(f'{ahead} commit(s) ahead', Style.GREEN)}")
+        print(f"     Remote: {colorize(f'{behind} commit(s) ahead', Style.YELLOW)}")
+        print()
+
+        if prefer_rebase or auto_confirm:
+            # Auto mode or --rebase flag → rebase
+            strategy = "rebase"
+        else:
+            choice = _prompt_choice(
+                "Choose strategy [1/2/3]: ",
+                [
+                    colorize("Rebase", Style.GREEN) + " — replay your commits on top of remote (clean history)",
+                    colorize("Merge", Style.CYAN) + "  — merge remote into local (preserves history)",
+                    colorize("Abort", Style.RED) + "   — cancel sync",
+                ]
+            )
+            if choice == 0:
+                strategy = "rebase"
+            elif choice == 1:
+                strategy = "merge"
+            else:
+                print(colorize("\n🛑 Sync aborted.", Style.YELLOW))
+                return 0
+
+        if strategy == "rebase":
+            success = _pull_rebase(remote, branch, cwd=cwd)
+        else:
+            success = _pull_merge(remote, branch, cwd=cwd)
+
+        if not success:
+            _print_sync_footer(False)
+            return 1
+
+        # After successful rebase/merge, push
+        print()
+        success = _push(remote, branch, cwd=cwd)
+        _print_sync_footer(success)
+        return 0 if success else 1
+
+    # ── Fallback (shouldn't reach here) ──────────────────────────
+    print(colorize("ℹ️  Could not determine sync state.", Style.DIM))
+    _print_sync_footer(False)
+    return 1

{gitpush_tool-0.4.2 → gitpush_tool-0.4.3/gitpush_tool.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitpush-tool
-Version: 0.4.2
+Version: 0.4.3
 Summary: Supercharged Git push tool with automatic GitHub repo creation and pushing
 Home-page: https://github.com/inevitablegs/gitpush
 Author: Ganesh Sonawane
@@ -38,7 +38,9 @@ A supercharged Git CLI and safety tool that simplifies repository creation and p
 
 ## ✨ Features
 
+- **Smart Sync Engine (`gitpush sync`):** Intelligent single-command replacement for `git pull → git add → git commit → git push`. Automatically detects repository state (clean, dirty, ahead, behind, diverged) and safely synchronizes with remote.
 - **Decision-Support Status Dashboard (`gitpush status`):** Actionable repository overview showing worktree breakdown, commit sync, intelligent next-step recommendations, and a 0-100 Repo Health score.
+- **Interactive Undo Engine (`gitpush undo`):** Reversible and safe rollback for commits and pushes with detailed previews.
 - **Pre-Push Safety & Diffstat Preview:** See changed files, line additions/deletions (`+X, -Y`), ahead/behind status, and pending commits before pushing.
 - **Dangerous Git Operation Guard:** Analyzes and protects against risky actions (`reset --hard`, force pushes, deleting unmerged branches, dirty `git clean`, detached HEADs).
 - **Protected Branch Safeguard:** Automatically detects and alerts when pushing or force-pushing to `main`, `master`, `prod`, `release`, or `dev`.

{gitpush_tool-0.4.2 → gitpush_tool-0.4.3}/gitpush_tool.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ gitpush/__init__.py
 gitpush/cli.py
 gitpush/safety.py
 gitpush/status.py
+gitpush/sync.py
 gitpush/undo.py
 gitpush_tool.egg-info/PKG-INFO
 gitpush_tool.egg-info/SOURCES.txt
@@ -18,4 +19,5 @@ gitpush_tool.egg-info/top_level.txt
 tests/test_cli.py
 tests/test_safety.py
 tests/test_status.py
+tests/test_sync.py
 tests/test_undo.py

{gitpush_tool-0.4.2 → gitpush_tool-0.4.3}/gitpush_tool.egg-info/entry_points.txt

@@ -2,4 +2,5 @@
 gitpush = gitpush.cli:run
 gitpush-guard = gitpush.cli:run
 gitpush-status = gitpush.cli:run
+gitpush-sync = gitpush.cli:run
 gitpush-undo = gitpush.cli:run

{gitpush_tool-0.4.2 → gitpush_tool-0.4.3}/setup.py

@@ -6,7 +6,7 @@ long_description = (Path(__file__).parent / "LONG_DESCRIPTION.md").read_text(enc
 
 setup(
     name="gitpush-tool",
-    version="0.4.2",
+    version="0.4.3",
     packages=find_packages(),
     install_requires=[],
     entry_points={
@@ -14,7 +14,8 @@ setup(
             "gitpush=gitpush.cli:run",
             "gitpush-guard=gitpush.cli:run",
             "gitpush-status=gitpush.cli:run",
-            "gitpush-undo=gitpush.cli:run"
+            "gitpush-undo=gitpush.cli:run",
+            "gitpush-sync=gitpush.cli:run"
         ],
     },
     author="Ganesh Sonawane",

gitpush_tool-0.4.3/tests/test_sync.py

@@ -0,0 +1,153 @@
+import unittest
+import os
+import sys
+import tempfile
+import shutil
+import subprocess
+from pathlib import Path
+
+# Add package root to sys.path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from gitpush.sync import (
+    _auto_generate_message,
+    _stage_and_commit,
+    _get_tracking_info,
+    _has_remote,
+    run_sync_flow
+)
+from gitpush.safety import FileChangeStat, get_diffstat_summary
+
+
+class TestSyncEngine(unittest.TestCase):
+
+    def setUp(self):
+        # Create bare remote repository
+        self.remote_dir = tempfile.mkdtemp()
+        subprocess.run(["git", "init", "--bare"], cwd=self.remote_dir, capture_output=True, check=True)
+
+        # Create local clone / repo
+        self.local_dir = tempfile.mkdtemp()
+        subprocess.run(["git", "init"], cwd=self.local_dir, capture_output=True, check=True)
+        subprocess.run(["git", "config", "user.name", "Test User"], cwd=self.local_dir, capture_output=True, check=True)
+        subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=self.local_dir, capture_output=True, check=True)
+        subprocess.run(["git", "branch", "-M", "main"], cwd=self.local_dir, capture_output=True, check=True)
+        subprocess.run(["git", "remote", "add", "origin", self.remote_dir], cwd=self.local_dir, capture_output=True, check=True)
+
+        # Initial commit & push to set up origin/main
+        file1 = os.path.join(self.local_dir, "initial.txt")
+        with open(file1, "w") as f:
+            f.write("initial\n")
+        subprocess.run(["git", "add", "."], cwd=self.local_dir, check=True, capture_output=True)
+        subprocess.run(["git", "commit", "-m", "Initial commit"], cwd=self.local_dir, check=True, capture_output=True)
+        subprocess.run(["git", "push", "-u", "origin", "main"], cwd=self.local_dir, check=True, capture_output=True)
+
+    def tearDown(self):
+        shutil.rmtree(self.remote_dir, ignore_errors=True)
+        shutil.rmtree(self.local_dir, ignore_errors=True)
+
+    def test_auto_generate_message(self):
+        mock_diff = {
+            "modified_count": 1,
+            "total_additions": 5,
+            "total_deletions": 2,
+            "files": [FileChangeStat("foo.py", "M", 5, 2)]
+        }
+        msg = _auto_generate_message(mock_diff)
+        self.assertEqual(msg, "Update foo.py (+5, -2)")
+
+        mock_diff_multi = {
+            "modified_count": 3,
+            "total_additions": 10,
+            "total_deletions": 4,
+            "files": [
+                FileChangeStat("a.py", "M", 5, 2),
+                FileChangeStat("b.py", "A", 5, 0),
+                FileChangeStat("c.py", "D", 0, 2)
+            ]
+        }
+        msg_multi = _auto_generate_message(mock_diff_multi)
+        self.assertEqual(msg_multi, "Update 3 files (+10, -4)")
+
+    def test_stage_and_commit(self):
+        new_file = os.path.join(self.local_dir, "new_file.txt")
+        with open(new_file, "w") as f:
+            f.write("hello world\n")
+
+        success = _stage_and_commit("Test commit", cwd=self.local_dir)
+        self.assertTrue(success)
+
+        # Verify status is clean
+        diff = get_diffstat_summary(cwd=self.local_dir)
+        self.assertFalse(diff["has_changes"])
+
+    def test_sync_already_synced(self):
+        # Local and remote are currently identical
+        ret = run_sync_flow(auto_confirm=True, cwd=self.local_dir)
+        self.assertEqual(ret, 0)
+
+    def test_sync_scenario_a_local_ahead(self):
+        # Scenario A: Local commits ahead, remote has 0 new commits -> Safe to push
+        new_file = os.path.join(self.local_dir, "feature.txt")
+        with open(new_file, "w") as f:
+            f.write("feature commit\n")
+        subprocess.run(["git", "add", "."], cwd=self.local_dir, check=True, capture_output=True)
+        subprocess.run(["git", "commit", "-m", "Add feature"], cwd=self.local_dir, check=True, capture_output=True)
+
+        ret = run_sync_flow(auto_confirm=True, cwd=self.local_dir)
+        self.assertEqual(ret, 0)
+
+        # Check that remote now has the commit
+        res = subprocess.run(["git", "rev-list", "--count", "origin/main...main"], cwd=self.local_dir, capture_output=True, text=True)
+        self.assertEqual(res.stdout.strip(), "0")
+
+    def test_sync_scenario_c_dirty_tree(self):
+        # Scenario C: Modified files detected -> auto-commits and pushes
+        new_file = os.path.join(self.local_dir, "dirty.txt")
+        with open(new_file, "w") as f:
+            f.write("dirty worktree\n")
+
+        ret = run_sync_flow(auto_confirm=True, commit_message="Auto committed dirty file", cwd=self.local_dir)
+        self.assertEqual(ret, 0)
+
+        # Check that worktree is clean and pushed
+        diff = get_diffstat_summary(cwd=self.local_dir)
+        self.assertFalse(diff["has_changes"])
+
+        res = subprocess.run(["git", "rev-list", "--count", "origin/main...main"], cwd=self.local_dir, capture_output=True, text=True)
+        self.assertEqual(res.stdout.strip(), "0")
+
+    def test_sync_scenario_b_diverged_rebase(self):
+        # Scenario B: Local is ahead, and remote has new commits -> diverged
+        # Create a second local clone to make commits and push to remote
+        second_local = tempfile.mkdtemp()
+        try:
+            subprocess.run(["git", "clone", "-b", "main", self.remote_dir, second_local], capture_output=True, check=True)
+            subprocess.run(["git", "config", "user.name", "Teammate"], cwd=second_local, capture_output=True, check=True)
+            subprocess.run(["git", "config", "user.email", "teammate@example.com"], cwd=second_local, capture_output=True, check=True)
+            
+            with open(os.path.join(second_local, "remote_work.txt"), "w") as f:
+                f.write("remote work\n")
+            subprocess.run(["git", "add", "."], cwd=second_local, check=True, capture_output=True)
+            subprocess.run(["git", "commit", "-m", "Remote teammate commit"], cwd=second_local, check=True, capture_output=True)
+            subprocess.run(["git", "push", "origin", "main"], cwd=second_local, check=True, capture_output=True)
+
+            # Local has its own distinct commit
+            with open(os.path.join(self.local_dir, "local_work.txt"), "w") as f:
+                f.write("local work\n")
+            subprocess.run(["git", "add", "."], cwd=self.local_dir, check=True, capture_output=True)
+            subprocess.run(["git", "commit", "-m", "Local commit"], cwd=self.local_dir, check=True, capture_output=True)
+
+            # Run sync with prefer_rebase=True
+            ret = run_sync_flow(auto_confirm=True, prefer_rebase=True, cwd=self.local_dir)
+            self.assertEqual(ret, 0)
+
+            # Both files should exist in local_dir
+            self.assertTrue(os.path.exists(os.path.join(self.local_dir, "remote_work.txt")))
+            self.assertTrue(os.path.exists(os.path.join(self.local_dir, "local_work.txt")))
+        finally:
+            shutil.rmtree(second_local, ignore_errors=True)
+
+
+if __name__ == "__main__":
+    unittest.main()

gitpush_tool-0.4.2/gitpush/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.4.2"