pilegit (pgit)

Git stacking with style — manage, squash, reorder, and submit stacked PRs from an interactive TUI.

Develop on a single branch, organize commits into reviewable chunks, submit each as a stacked PR. Full undo restores actual git state. Works with GitHub, GitLab, Gitea, Phabricator, and custom commands.

Install

cargo install pilegit

Or build from source:

git clone https://github.com/hokwangchoi/pilegit.git
cd pilegit
cargo install --path .

This installs the pgit binary.

Quick Start

pgit          # launch TUI (prompts setup on first run)
pgit init     # re-run setup
pgit status   # show stack non-interactively

Keybindings

Select mode: V to start → j/k extend → s squash → Esc cancel
Diff view: j/k scroll · Ctrl+↑↓ half-page · q back

Setup

First run prompts for platform and base branch. Saved to .pilegit.toml:

[forge]
type = "github"    # github | gitlab | gitea | phabricator | custom

[repo]
base = "origin/main"

Stacked PRs

Each commit → one PR. pilegit manages base branches so each PR shows only its diff:

Stack:                       PRs:
┌ feat: dashboard            PR#15 base=pgit/.../feat-auth
│ feat: auth middleware       PR#14 base=main (parent merged)
└ feat: migrations            ← merged, branch cleaned up

Branch naming: pgit/<username>/<subject> — multi-user safe.

Press s to sync: force-push all branches, update bases, prompt to clean up stale branches.

Remote Pull

Press P to pull remote PR changes into your local stack. This enables collaboration — if someone else updates a PR in your stack, pgit detects the change and merges it into your local commits.

You submit PRs → colleague updates PR #2 → you press s
  ⚠ Remote has newer changes. Press P to pull first.
You press P → remote changes merged into local commits
  ✓ Pulled remote changes for 1 PRs.
You review, make more changes, then press s to sync.

Sync state is tracked in .git/pgit-sync-state.json (branch hashes for GitHub/GitLab/Gitea, diff PHIDs for Phabricator). Any push that doesn't match the saved state is flagged before overwriting.

Under the Hood

Forge Trait

Adding a new platform = implementing one trait:

pub trait Forge {
    fn submit(&self, repo: &Repo, hash: &str, subject: &str,
              base: &str, body: &str) -> Result<String>;
    fn update(&self, repo: &Repo, hash: &str, subject: &str,
              base: &str) -> Result<String>;
    fn list_open(&self, repo: &Repo) -> (HashMap<String, u32>, bool);
    fn edit_base(&self, repo: &Repo, branch: &str, base: &str) -> bool;
    fn mark_submitted(&self, repo: &Repo, patches: &mut [PatchEntry]);
    fn sync(&self, repo: &Repo, patches: &[PatchEntry],
            on_progress: &dyn Fn(&str)) -> Result<Vec<String>>;
    fn check_diverged(&self, repo: &Repo, patches: &[PatchEntry])
            -> Vec<(String, String)>;
    fn get_remote_ref(&self, repo: &Repo, patch: &PatchEntry)
            -> Option<String>;
    fn save_sync_state(&self, repo: &Repo, patches: &[PatchEntry]);
    fn name(&self) -> &str;
}

Comparison

Architecture

src/
├── main.rs            # CLI — TUI, status, init
├── core/
│   ├── config.rs      # .pilegit.toml + setup wizard
│   ├── stack.rs       # Stack data model
│   └── history.rs     # Undo/redo with HEAD hash tracking
├── git/
│   └── ops.rs         # Git operations (rebase, squash, swap, etc.)
├── forge/
│   ├── mod.rs         # Forge trait + factory
│   ├── github.rs      # GitHub (gh)
│   ├── gitlab.rs      # GitLab (glab)
│   ├── gitea.rs       # Gitea (tea)
│   ├── phabricator.rs # Phabricator (arc)
│   └── custom.rs      # Custom command
└── tui/
    ├── mod.rs         # Terminal + suspend/resume handlers
    ├── app.rs         # State machine (modes, cursor, forge)
    ├── input.rs       # Keybinding dispatch
    └── ui.rs          # Ratatui rendering

License

MIT