GitInProgress

AI drafts the commits. You decide what ships. GitInProgress turns a messy working tree into reviewable commit candidates: your own AI proposes how to split the changes into focused commits — each with a draft commit message — then you refine the grouping, tweak the messages, and commit. Nothing lands in history until you approve it — the AI never commits on its own. Along the way you can test each grouping in isolation and iterate safely.

Git records commits after the fact. GitInProgress shapes them before — nothing lands in history until you approve.

GitInProgress opens in the bottom panel (alongside the integrated Terminal) and turns a messy working tree into reviewable commit candidates — group related changes, tweak the AI's draft messages, and keep debug-only changes parked out of every commit until you remove them.

What it does

AI commit splitting (core)

Stop staring at a giant pile of unsorted changes. Your own AI client (via MCP or GitHub Copilot) reads your working tree and proposes a clean way to break it into commit candidates — small, focused groups of changes, each with a ready-to-edit commit message drafted for you. Just ask your AI: "Draft my commits."

• You stay in control — these are proposals, not commits. Nothing enters your git history until you review, tweak, and confirm.
• Nothing slips through the cracks — changes you haven't sorted yet collect in an Inbox, pinned to the top, so you always know what still needs a home. You or the AI file them into candidates from there.
• Organize the way you think — gather changes into named candidates (we call them ChangeBoxes) with drag & drop, multi-select, color-coding, and reordering.
• Split even within one file — a single file often touches two unrelated things. From the diff view you can send each individual edit (a "hunk") to a different ChangeBox — e.g. "move this hunk to Debug." The commit then stages only the lines that candidate owns; the rest stay untouched.
• Commit one group at a time — turn a single candidate into a commit without disturbing anything else in your working tree.

Each candidate (a ChangeBox) groups related files with an editable draft message — review it, tweak it, and commit one at a time. The Debug box is parked, so it stays out of every commit.

Safety nets ⚡ Pro Preview (currently free)

Experiment freely — you can always get back to a known-good state. (On the Free tier, deleting a file simply discards it, with no recovery.)

• Archive — a non-destructive checkpoint that preserves a candidate's ChangeBox grouping while clearing it out of your working tree. Restore it by hand whenever you need it.
• Snapshot — capture a restorable copy of your work while leaving it in place, so you can keep editing.
• Auto set-aside on branch switch / pull — switching branches or pulling with uncommitted work automatically sets it aside (grouping intact) and offers to bring it back when you return.
• Trash — a recycle bin with a 30-day recovery window. Restore single files or whole ChangeBox groups. Trash is only ever cleared when you explicitly choose to.
• Trash-backed AI iteration — a candidate that didn't pan out goes to Trash, where you can ask the AI for a different take without losing the old one.

Archive lifts your work out of the working tree while keeping each candidate's grouping — parked boxes included — ready to restore by hand whenever you need it.

Trash keeps removed files for 30 days, grouped by the candidate they came from — restore a single file or a whole group, and it's cleared only when you say so.

Isolation testing ⚡ Pro Preview (currently free)

Try a slice of your work on its own to see if it actually builds and passes — without losing the rest.

• Test a prefix in isolation — choose how many of your commit candidates to keep live — the first N, as a prefix (#1, #1–#2, …) — build/test just those, and the rest are set aside, then restored when you're done.

Keep a prefix of your candidates (here #1–#2) live to build and test on their own; everything below the line is set aside, then restored when you're done.

Work context

Remember why you were here and where you left off.

• Branch memos — attach a note and a status (In Progress / Review / Waiting Merge / Abandoned) to each branch. When you switch back, the previous note pops up so you instantly pick up the thread.
• File progress — see each file's unstaged and staged changes side by side on one row, with added / removed line counts and arrow buttons to stage or unstage, in a collapsible tree (or flat list).

Commit & Push

Finish the job without leaving the panel — commit and push with automatic remote detection and warnings when your branch isn't tracking a remote.

MCP server — AI integration

Let your AI commit the right way. GitInProgress ships an MCP (Model Context Protocol) server (stdio) so AI clients — Claude Code, GitHub Copilot Chat, Cursor, and any MCP-compatible client — can read your work-in-progress and commit through your candidates instead of running raw git commit. It exposes read tools plus write tools that are always recoverable; destructive actions (emptying trash, permanent delete) are deliberately left out, so an AI can never wipe your work.

→ See MCP_SETUP.md for client registration steps and the full tool list.

Pricing

GitInProgress is free for everyone during early access.

Free (core experience)

• AI commit splitting (create commit candidates from your own AI)
• Manual ChangeBox editing, per-changeBox commit, and Commit All
• Inbox / Branch memo — deleting a file discards it (no recovery)
• MCP server integration (Claude Code / Copilot / Cursor read & commit through your splits)

⚡ Pro Preview (currently free)

(See What it does above for details.)

• Safety nets — Archive, Snapshot, Auto set-aside on branch switch / pull, and Trash (30-day recovery; on Free, deleting a file just discards it)
• Isolation testing — build/test the first N commit candidates (a prefix) on their own
• Trash-backed AI iteration — failed candidates go to Trash; ask the AI for an alternative

Pro pricing is TBD, planned for the v1.0+ stable release. During early access, Pro Preview features are free so you can evaluate the full feature set.

How data is stored

All data (memos, file progress, change boxes, trash metadata) is saved under .git/gitinprogress/ inside your repository. It's local to each repo and ignored by git — nothing is sent to any server. Your AI client only sees this data when you invoke the MCP server.

For worktrees, each worktree gets an independent state at <main>/.git/worktrees/<name>/gitinprogress/ (see docs/WORKTREE_SUPPORT.md for details).

Requirements & current limitations

• VS Code 1.105+ (the bundled MCP server integration needs 1.99+)
• A Git repository in the workspace
• Single-root workspace only: multi-root workspaces are not supported in v0.1.x — only the first workspace folder is tracked. Open each project in its own window for now.
• For git worktree users: open each worktree directory in a separate window (worktree-aware: ✅, cross-worktree view: ❌).

Getting started

1. Install the extension from the Marketplace.
2. Open a git repository in VS Code.
3. Open the bottom panel (Ctrl/Cmd+J) and select the GitInProgress tab — it sits next to Terminal, Output, and Problems.
4. (Optional) Connect your AI client — see MCP_SETUP.md.
5. After editing files, ask your AI: "Draft my commits" — then review and commit each candidate yourself. (No AI connected? Group changes by drag & drop instead.)

GitInProgress runs in the bottom panel, like the integrated terminal — open it with Ctrl/Cmd+J and pick the GitInProgress tab (next to Terminal / Output / Problems).

Support

GitInProgress is maintained by a single developer (solo dev). Bug reports and feature requests are triaged on a best-effort basis — there is no SLA. During early access, you're encouraged to use the Pro Preview features and share feedback before the v1.0 launch.

Bug reports & feature requests

Open an issue in the public issue tracker. Please use the provided issue templates and include:

• VS Code version
• GitInProgress version
• OS
• Steps to reproduce
• Expected vs actual behavior
• Logs from the Output → GitInProgress channel (if relevant)

Issues without sufficient reproduction information may be closed after 7 days of inactivity.

Security vulnerabilities

Do not file public issues for security concerns. Please use GitHub's private security reporting:

1. Go to the Security tab of the issue tracker
2. Click "Report a vulnerability"
3. Fill in the form with details

You should receive an acknowledgment within 7 days.

General questions

Use the issue tracker with the question label.

Pro license / billing (v1.0+)

A dedicated email channel for Pro tier users will be added when the Pro tier launches in v1.0+.

License & legal

GitInProgress is proprietary software — see LICENSE for the full terms. The source is not publicly distributed; copying, modification, redistribution, and reverse engineering are not permitted. During early access (v0.1.x) the extension is free; some features may require a paid Pro license from v1.0 onward. The early-access period is your chance to evaluate everything first.

This extension bundles third-party open-source components, each under its own permissive license (MIT / ISC / BSD). See THIRD_PARTY_NOTICES.md for the full list and license texts.