From ticket to PR. One command. Git worktree lifecycle manager — isolated workspaces tied to your tickets, with stacked PRs, multi-forge support, and clean shipping.

$ parsec start PROJ-1234     # creates worktree, fetches Jira title, sets up branch
$ parsec ship PROJ-1234      # pushes, opens PR, cleans worktree

That's the whole loop. Plain git worktree doesn't track state, doesn't talk to your tracker, doesn't open PRs, doesn't clean up. parsec does.

• No index.lock collisions — every workspace has its own .git/index, so multiple developers (or AI agents) can run git add on the same repo at the same time.
• One command per phase — start (worktree + tracker fetch), ship (push + PR + cleanup), merge (merge + branch cleanup), clean (sweep merged branches). No web UI round-trips.
• Stacked PRs that don't melt your brain — parsec start FOO --on BAR chains workspaces; parsec stack --submit opens the whole stack in topological order with auto-posted "← prev / next →" navigation comments.
• Cross-worktree conflict detection — parsec conflicts flags files modified in two workspaces before anyone pushes.
• Multi-forge — GitHub, GitLab, Bitbucket Cloud. Multi-tracker — Jira, GitHub Issues, GitLab Issues, Bitbucket.
• Agent-friendly — --json on every command, structured error codes, JSONL execution log, headless/offline modes.

Vision: parsec = AI agents + human devs both — worktree-native git CLI.

v1.0 work is tracked under the v1.0 milestone; see the CHANGELOG for the full v0.5.0 release notes.

# Homebrew / pre-built binary (recommended)
curl -LO https://github.com/erishforG/git-parsec/releases/latest/download/parsec-x86_64-unknown-linux-gnu.tar.gz
tar xzf parsec-*.tar.gz && sudo mv parsec /usr/local/bin/

# Cargo (Rust toolchain required)
cargo install git-parsec

Other targets (macOS arm64/x86_64, Windows x86_64) ship on every release — see Releases. After install, run parsec config init for the interactive first-time setup, then parsec doctor to validate.

parsec ships dynamic completion scripts that suggest live worktrees and branches as you type (e.g. parsec switch <Tab> lists your active tickets).

# zsh — copy to a site fpath dir, or add the repo path to fpath:
cp completions/_parsec ~/.zsh/completions/      # then: fpath=(~/.zsh/completions $fpath)

# bash:
source completions/parsec.bash                  # or symlink into /etc/bash_completion.d/

# fish:
cp completions/parsec.fish ~/.config/fish/completions/

A purely static fallback (no live candidates) is also available via parsec config completions <shell> if you'd rather not source the dynamic scripts.

# Pull a ticket from Jira / GitHub / GitLab / Bitbucket and start work
$ parsec start PROJ-1234
✓ Worktree: ../myapp.PROJ-1234
  Title:    Add rate limiting (fetched from Jira)
  Branch:   feature/PROJ-1234

# See everything in flight
$ parsec list
╭───────────┬───────────────────┬────────┬─────────────────────────╮
│ Ticket    │ Branch            │ Status │ Path                    │
├───────────┼───────────────────┼────────┼─────────────────────────┤
│ PROJ-1234 │ feature/PROJ-1234 │ active │ ../myapp.PROJ-1234      │
│ PROJ-5678 │ feature/PROJ-5678 │ active │ ../myapp.PROJ-5678      │
╰───────────┴───────────────────┴────────┴─────────────────────────╯

# Hop in (shell integration auto-cd's)
$ parsec switch PROJ-1234

# Make commits the normal way, then ship — push + PR + cleanup in one shot
$ parsec ship PROJ-1234
✓ Pushed feature/PROJ-1234
✓ PR opened: github.com/org/repo/pull/42
✓ Worktree cleaned up

# Watch CI without leaving the terminal
$ parsec ci PROJ-1234 --watch

# Merge from terminal once CI is green
$ parsec merge PROJ-1234

$ parsec start PROJ-2 --on PROJ-1   # new worktree on top of PROJ-1's branch
$ parsec stack --submit              # open all PRs in the stack, root first

parsec auto-posts ← previous PR / next PR → navigation comments so reviewers can walk the chain.

• Forges: GitHub · GitLab · Bitbucket Cloud (full PR lifecycle on each)
• Trackers: Jira · GitHub Issues · GitLab Issues · Bitbucket
• CI status: GitHub Actions · GitLab CI · Bitbucket Pipelines

parsec ci and pr-status work the same shape across all of them.

Every command has --json. Errors emit structured codes (E001…E013). parsec log --export outputs JSONL with execution IDs and per-step timing for tooling/agents to consume. --offline and [behavior].offline config skip all network ops for air-gapped or CI environments.

parsec clean sweeps worktrees for already-merged branches. parsec conflicts flags cross-worktree file overlap before you push. parsec undo reverses the last operation (start, ship, clean). parsec doctor validates every part of your setup with actionable fix instructions.

[worktree].shared_cache = ["target", "node_modules", ".venv"] lets new worktrees reuse the main repo's caches via symlink (default) or copy. Eliminates cold-build cost on parsec start for any project with significant dependency caches.

parsec board turns your active sprint into a Kanban board in the terminal. parsec create and parsec new-issue open issues in your tracker without leaving the shell.

• parsec smartlog (alias sl) — ASCII commit DAG of every active worktree with PR / CI overlay.
• parsec dashboard (alias dash) — real-time TUI panel showing worktrees, CI, and PRs in one screen (ratatui + crossterm).
• parsec health — lock / uncommitted / stale / CI checks across every worktree, with a configurable stale threshold.
• parsec reviews — open PR reviews you've received vs. requested, unified across worktrees.
• parsec conflicts --simulate — in-memory three-way merge to surface real line-level conflicts before you push (worktree-vs-base + cross-worktree pairs, read-only).
• parsec test — run tests in parallel across worktrees with tree-hash result caching (--all --jobs N --cache).
• parsec commit — AI-generated commit messages from staged diff (OpenAI / Anthropic, --conventional for Conventional Commits).
• parsec sync — fast-forward stale worktrees against origin/<base> (rebase or merge, --all, --dry-run).

33+ commands total — see the full command reference for every flag and example.

Each PR body includes a stack navigation table:

# ~/.config/parsec/config.toml
#:schema https://json.schemastore.org/parsec.json

[workspace]
layout         = "sibling"      # ../repo.ticket/  (alt: "internal")
branch_prefix  = "feature/"
offline        = false           # true = skip all network ops

[tracker]
provider = "jira"               # jira | github | gitlab | bitbucket | none

[tracker.jira]
base_url = "https://yourcompany.atlassian.net"
# Auth: PARSEC_JIRA_TOKEN env var

[ship]
auto_pr      = true
auto_cleanup = true
draft        = false             # true = open PRs as drafts
# template   = ".github/PULL_REQUEST_TEMPLATE.md"

[worktree]
shared_cache    = ["target", "node_modules", ".venv"]
cache_strategy  = "symlink"      # alt: "copy"

Auth tokens (set via env vars, all optional):

PARSEC_JIRA_TOKEN       PARSEC_GITHUB_TOKEN       PARSEC_GITLAB_TOKEN
PARSEC_BITBUCKET_TOKEN  GITHUB_TOKEN (fallback)   GITLAB_TOKEN (fallback)
PARSEC_OFFLINE=1        — force offline mode globally

Full schema and every option: parsec config schema (also published to schemastore.org).

• 📘 Getting Started Guide — install, first ship, tracker config, recipes
• 📗 Command Reference — every command, every flag, with examples
• 🌐 Project home — features tour and live demo

Every command exits with a structured code. JSON output (--json) includes the same code:

$ parsec ship PROJ-1234 --json 2>&1
{"error":{"code":"E001","message":"No GitHub token configured","hint":"Set PARSEC_GITHUB_TOKEN or run gh auth login"}}
$ echo $?
2

MIT — see LICENSE.