repository·main·Indexed 24 days ago
https://github.com/git-town/git-townA CLI tool that automates Git workflows, focusing on branch management, synchronization, and stacked changes. It supports workflows such as Git Flow, GitHub Flow, GitLab Flow, and trunk-based development, providing specialized support for mono-repos and dependent branch stacks.
Git Town is a high-level CLI that provides a reusable implementation of Git workflows. It is designed to replace manual, error-prone Bash scripts with engineered commands for common version control scenarios.
Key capabilities include:
Git Town is compatible with several branching models, including:
Git Town categorizes branches into two primary groups: Long-lived (perennial) and Short-lived.
Also called perennial branches, these are branches that exist indefinitely (e.g., main, master, development). The main branch is a special perennial branch that serves as the default base for cutting and merging short-lived branches.
Used for active development, these are typically created from and merged back into a perennial branch. They are further categorized by ownership:
Owned by you:
Owned by others:
Git Town operates using an interpreter-based execution model and a snapshot-based undo mechanism to ensure reliability and recoverability.
Git Town commands are not hard-coded scripts; they are programs composed of Git-related opcodes executed by an interpreter.
To revert changes made by a command, Git Town:
Git Town is designed to be compatible with other Git tools and the broader Git ecosystem.
Your entire team does not need to use Git Town to benefit from it. Even as a solo user, Git Town provides value by automating standard Git commands that are typically required to maintain a tidy repository and keep branches in sync.
Git Town uses specific branch types to determine how git town sync or git town sync --all behaves. Each type has unique rules for syncing with parents, tracking branches, and whether the branch can be 'shipped'.
| branch type | description | syncing behavior | ship |
|---|---|---|---|
main | primary development branch | sync with origin, pull from upstream | no |
perennial | long-lived branch (e.g., develop, staging) | sync with origin | no |
feature | normal feature branch | sync with parent and tracking branch | yes |
prototype | work-in-progress feature | sync with parent, don't push to tracking | yes |
parked | inactive feature branch | no syncing | yes |
contribution | someone else's branch, you share changes | sync with tracking | no |
observed | someone else's branch, you don't share changes | pull from tracking | no |
Git Town is designed to be flexible and supports a wide range of branching strategies, including:
It is also compatible with workflows where commits are made directly to the main branch.
While git-flow is a specialized extension focused on providing opinionated support for the specific Git Flow branching model, Git Town is model-agnostic. Git Town focuses on:
You can use Git Town alongside git-flow if your workflow requires both.
Git Town uses a hierarchical configuration system. Settings are applied in the following order of precedence (from lowest to highest):
lint_cached_connectors tool is a linter designed to ensure that cached connectors in internal/forge are interchangeable with their uncached counterparts. It verifies that every cached connector implements the exact same interfaces as its corresponding uncached connector.Git Town uses specific configuration entries to track the lineage of branches. These entries follow the pattern git-town-branch.<branch>.parent=<branch>, where <branch> is the name of the branch and its parent.
Note: You do not need to manually manage or edit these entries. Git Town automatically maintains this lineage as it creates and removes feature branches.
The linter automates the verification of interface implementations by following these steps:
var _ forgedomain.ProposalFinder = apiConnector).