Mergerie
Contents

Git

This page is generated from docs/guide.en.md · Edit this page on GitLab

Operations across several repositories at once, and branch exploration.

  • Actions — Create a branch · Create a tag · Delete branches · Delete tags. You only type a name to create; to delete, you pick from the list of existing refs — the default branch and protected refs are not even in it. The repository is chosen through a field with search (as everywhere a project is picked), which matters when the list is long — and so is the ref: an active repository has hundreds of branches and tags. A single choice goes through a selector with search; a multiple choice (checkboxes, the explorer's table) gets a filter that hides rows without unticking anything — you tick, you filter something else, you tick again, then you delete in one go. The ref list is read once per repository: Refresh the list re-reads it from the forge — and it re-reads itself when a git operation finishes, so the branches you just deleted leave the list, with the chosen repositories and the still-valid ticks kept in place.
  • Nothing runs without a preview. The preview lists each row (project × ref) and its expected outcome: will run · already exists — skipped · protected ref · default branch · not found. “Already exists” is not an error: the operation is idempotent, you can run it again. Each actionable row also shows the matching command: the one actually executed (the safety git fetch), the git equivalent of the write — given so you can understand it, since the write goes through the API and not the CLI — and the underlying API call.
  • Deletions are restorable. Before every deletion, the tool pulls the objects into its local clone, then records the SHA. The History tab then offers Restore — and it works even after the forge's garbage collector has run, since it is the local clone that acts as the safety net, not the server.
  • The branches of merged merge requests gather into one lot. A button at the head of Actions fills the deletion with every branch whose merge request was merged — the usual preview then says, branch by branch, whether it still exists and whether deleting it is safe. Past ten or so, the morning brief mentions it.
  • Three sub-tabs that remember. Merge keeps its repository and both branches, Actions its operation and its repositories — as Compare, Navigate and Commands already did. Neither branch names nor the refs ticked for a deletion are restored: re-ticking is precisely the gesture that makes you re-read what you are about to delete.
  • A branch name proposes itself: the last name created with its number incremented (release/1.4 → release/1.5), or the ticket key from the clipboard — read on a click, never in the background.
  • Two gestures from the explorer: Verify this branch and Coding session on it start with the repository and the branch already filled in. And Find a ref offers Check my projects out on it, which opens Navigate with the ref set on every row.
  • Merge — merges one branch into another, conflicts and all, without leaving the tool. You pick a repository, the branch to merge and the branch to merge it into (both with a search field: an active repository carries hundreds of branches), then Prepare the merge. At that point nothing is committed or pushed: the merge is prepared in a workspace of its own, never in the shared clone — a review, a coding session or a verification running alongside must not find the repository half-merged. A merge can be resumed after the tool restarts.
    • The open merge moves to the top of the tab, above the list of running merges (where its row says "open above") and the form, which becomes "Prepare another merge". Its banner carries the three steps Resolve › Commit › Push, the current one highlighted, the done ones ticked; on the left, the files still in conflict, then, ticked, those already ready to commit. A merge whose working folder is gone (prepared on another machine, disk clean-up) says so plainly and only offers to abandon it, instead of an empty panel.
    • Conflicts are resolved on screen, one at a time. For each conflict: the destination's version and the incoming version, one under the other, with Keep on each and Keep both: <destination> then <source> — the button names the two branches and the order it applies them in — below them; the side you keep carries a coloured bar and the word "kept", so you can see where you stand without re-reading the buttons — the destination is kept by default — and each version can be clicked as a whole, not only its Keep. You never see a <<<<<<< marker. When neither side fits, Write it myself hands you the result of your choices in a plain text field and saves what you write.
    • Then two separate gestures, in that order. Commit — the message is already filled in with the one git itself wrote — then Push, each behind its own confirmation. Commit refuses while a conflict remains; Push refuses while nothing is committed. Abandon restores everything: until you push, the destination branch has not moved.
    • When the two branches share no common ancestor, the tool explains what that means and offers to go ahead anyway (--allow-unrelated-histories), instead of passing on git's bare fatal: refusing to merge unrelated histories.
    • Each side says when it was last touched. Above each version, the date and time of the last commit on that branch: picking the more recent one no longer means guessing, even when both were made the same day.
    • Fullscreen shows the whole file three times side by side — destination, the current result in the middle, source — instead of three lines of context per conflict. Clicking a passage on either side still keeps it, and the choice carries back to the normal view on close; Keep both and manual editing stay in the normal view. Previous / next conflict arrows jump straight to the next one, with a “Conflict N of M” counter; on a file with a single conflict, or at either end, they re-center and re-mark it rather than looking broken. Each column can be hidden and shown back on its own — the others share the freed-up width, and one always stays visible.
    • Ask the AI proposes a resolution for every conflict of every file in one go — one button on the conflict screen, not one per file: the whole merge goes to the agent as a single background job, so it sees every conflicted file together before proposing anything (a fix that only makes sense read alongside a change in another file is not lost by asking file by file). The button asks for confirmation first: the content of every conflicted file leaves for the agent. Each proposal then shows up as a third version next to “ours” and “theirs”, with its own Keep — nothing is applied on its own, and a conflict the agent skipped simply shows no third version rather than a guess. See reason unfolds the agent's short explanation for that conflict. Proposals are kept with the merge, so reopening a file does not lose them. In fullscreen, a fourth column carries the proposal and its reason on a file that has one; clicking it selects it, like a passage on either side.
  • Navigate — checks out several projects on your machine (not the tool's clones: your own repositories) on the branch of your choice, in one gesture. You pick a local directory — a folder holding one subfolder per git project, declared in Settings → Repositories, where each directory lists the projects found and is re-read from disk with a button: a folder deleted by hand disappears, a repository cloned since appears, here as in the pickers — then, row by row, a project and its remote branch, both with search as you type. The current branch is shown next to the selector: without it you choose blind, not knowing whether the operation changes anything at all. A git fetch precedes the branch list and the checkout, and the local branch is then aligned fast-forward only (a diverged history is reported, never overwritten). Nothing is discarded: if a repository has pending changes, the checkout is done anyway and the summary lists the affected files — a count would not let you check what you are carrying from one branch to the other. A failure (missing branch, refused checkout) is isolated: it does not stop the other projects, and its reason is shown.
  • Git commands — runs the same git command at the root of several local projects at once. You pick a local directory, tick the projects (search + “check all”), then type a git command or take it from a palette (managed in Settings → Git). A three-step flow: Preview (the exact command + the list of targeted projects) → Run → each project's output appears, with its exit code. Git only, without a shell (the metacharacters ; | > & are never interpreted) and with a refusal of dangerous git options: the flags that allow running an arbitrary command or escaping the folder (-c, --upload-pack, --receive-pack, --exec, -C, --git-dir, the ext:: transport…) are blocked, and the command must start with a subcommand. A failing project is isolated; the others still run.
  • Branch explorer — per project, one row per branch with its columns: ↑ahead ↓behind versus the default branch, its branch of origin, the branch it was merged into and its last commit. Sorted by last-commit date, most recent first. From a branch, Create MR opens an MR between it and its source (the inferred origin, otherwise the default branch) — the same title popup as in AI Dev, offered only when the branch has commits ahead. Ticking branches then Delete selection opens the pre-filled preview. Every row also carries what the database knows about the branch: the score of its merge request's review, the coding session that created it, its Jira ticket and that ticket's state, the last verification verdict — and, when the repository has a declared Jenkins job, a button that opens that job with the branch already filled in. The button existed only on a merge request verified green: a branch you want to deploy to staging before turning it into a merge request had no right to it. The sheet opens, never a run. The row finally takes a todo (“rebase before Monday”), which knows how to bring you back. The repository picker carries Check all / Uncheck all with a running count of what is ticked, as Git commands already did. You can also explore several repositories at once (each result in a collapsible block, folded and marked with a chevron that rotates — repositories are analysed one after another, and each block says where it stands (waiting, then analysing with its spinner, then its branch count). A clone can take a minute: the button spins meanwhile, and a repository that fails opens its block to show why instead of leaving it shut. The tag list shows the date, the branch(es) that carry the tag and the author of the pointed commit — with a Tag author button that reads the real tagger of an annotated tag in the local clone (neither forge API exposes it).
  • Compare — two repositories, one branch or tag on each side, and the question “what exists here and not there?” (comparing two released versions means comparing two tags; both live in the same searchable list, marked, because a branch and a tag may carry the same name). This is not a git diff: the two repositories need no common history (a service extracted into its own repository, a fork gone its own way). The tool reads both trees and sorts every file into one of three columns: left only, on both sides but different (same path, different content), right only. Identical files are not listed — only counted, so the screen shows what is missing rather than what is fine. Clicking a file shows its differences: both versions as a unified diff, with a reminder of which side is the red one and which is the green one. A file present on one side only is read against the void — all of its content as removals (or additions), which is precisely what the other side is missing. A binary file says so instead of dumping its bytes, and a file over one megabyte is not loaded — stated, not hidden. A filter searches all three columns at once. Both sides may point at the same repository on two branches. Beyond 2,000 files per column the lists are truncated and the truncation is announced — never silent.
  • Find a ref — you type a tag or branch name (free text) and the tool says, across every active repository (GitLab and GitHub alike), which ones have it: type, commit + link to the forge, date, the branch(es) carrying the tag, the author — with the same Tag author button. An unreachable repository is reported separately, never confused with “absent”.
  • Tags by period — “what did we ship these two weeks?”. Two dates (shortcuts Last 7 and Last 30 days; the last 30 are set when the sub-tab opens) and the tool lists every tag created between those two days, both included, across all active repositories: repository, tag (link to the forge), date and time (two tags of the same day stay apart), first line of the message. The cross at the end of a row hides it — a test tag, a hotfix nobody announces — and “Show all” brings it back; Copy the table puts the visible rows in the clipboard in two forms at once — a real HTML table, which Teams, an email or Word render as a table, and tab-separated text for a spreadsheet or a plain editor. Verify these tags asks the next question: “does what we shipped still pass?” — it opens Verify a branch with the table's repositories ticked, each in Tag mode on its tag, hidden rows staying out; the proposed verifier is the one covering most of those repositories, the ones it does not cover are named under the selector, and a repository with several visible tags gets the most recent (changeable on its row). A tag's date is its creation date when the forge gives it (GitLab, annotated tags), otherwise the date of the commit it points to; GitHub tags, which the API does not date, are read from the local clone. A tag the tool cannot date is counted separately, never placed at random; an unreachable repository is named.

⚠️ A branch's origin is an inference, not a fact. Git records nowhere which branch a branch was created from. The tool infers it (merge-base), except when a merge request attests to it — the only certain case. An inferred origin is shown in italics with its confidence (likely / ambiguous), never as a fact.