Mergerie
Contents

Jira

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

Four sub-tabs: My tickets, Watched, Analysed and Stats. The menu carries a badge = the number of tickets in progress that are assigned to you (status category In Progress, the only definition that survives across workflows, since state names are free from one project to the next). It is fed by a counter cached server-side and refreshed by the watcher: showing it does not cost a Jira call every time you walk past.

My tickets

The Jira tickets, fetched automatically when you open the menu. By default only yours are shown, but a filter by person lets you tick other assignees to see their tickets too (the list of people = the accounts active over the last six months — assignees of a ticket that moved in that window, within the filter's projects if any, deactivated accounts and applications excluded; you ticked by default, a persisted choice). A list → detail layout:

  • The number of tickets in the list is shown in the toolbar and on the tab itself, and follows every filter (search, statuses, assignees, fields), not only the load.
  • The list (on the left, with search) shows each ticket as a compact card: key, the epic it belongs to when there is one, summary, status (a dot coloured by category: to do / in progress / done), type, priority, update date. The search covers the epic too — “show me the tickets of that epic” is a common ask. In the list the epic stays a piece of information — the whole card selects the ticket; it is in the detail that it becomes a link to Jira, opened in a new tab. The epic is read from Jira's parent field, keeping only the parents that really are one: a sub-task's parent is a story, and announcing it as an epic would be a contradiction. Tickets that are done are left out by default — an “Include done” checkbox brings them back. A filter by status (collapsible, checkboxes, a persisted choice) additionally lets you show only the statuses you want. It adapts to the custom statuses of your workflows, and the colour follows the status category (to do / in progress / done), not its name. The list is not limited to the displayed tickets: the statuses of the workflow of the projects concerned are loaded as well, otherwise a real status absent from the page would not be filterable. We query the selected projects, failing that the ones of the displayed tickets — asking for every status of the instance would give dozens of unrelated entries, and the endpoint that allows it requires administering Jira. Unticked statuses are excluded by Jira, not afterwards — otherwise we would be sorting a capped excerpt. A status already seen stays on offer even once excluded, without which you could no longer tick it back. A Sprints filter appears as soon as your tickets carry one. The sprint is a custom field whose identifier changes from one instance to another: the tool spots it by its Jira schema marker, which is language-independent — a field named “Iteration” is recognised as such. The selection is applied by Jira (sprint IN (…)), like the projects, so as not to sort a capped excerpt. Sprints already seen stay on offer once a sprint is chosen, otherwise you could not tick a second one. The current sprint sits at the top of the list and is flagged as such — it is the one you are after nine times out of ten, and the date alone does not tell it apart from a future sprint. Then come the others by descending date; a sprint with no known date (Jira does not always give one for a future sprint) comes after those that have one. Above the cards, a quick status filter: one checkbox per status present in the loaded tickets, with its count. Untick one and its cards leave at once, nothing asked of Jira; Show all brings them back; the choice is remembered. The Statuses menu on the right acts on the query instead: what you untick there is excluded by Jira, and changes what is loaded. The Assignees and Statuses filters each have their own search — which hides rows without unticking anything — and Check all / Uncheck all — handy to empty everything then keep only one or two rows. On the assignees, ticking nobody does not filter: the list then takes every ticket the account can see, including those assigned to someone else or to no one. By default, as long as you have touched nothing, only your tickets are loaded.
  • Filters by field, generic. The three filters — Assignees, Statuses and Filters — are chips lined up above the detail panel; the one you open floats over the page, so neither the row nor the list moves, and a click outside closes it. The Filters panel lets you choose the field first (epic, type, priority, project, team — Atlassian's Team field, found by its schema or its name “Team” / “Équipe” —, assignee, reporter, labels, components, fix versions) then one or more values. The Project criterion is an exception: it is applied by Jira, not afterwards. The list pages the Jira search up to 1,000 tickets sorted by update date (a Jira page holds a hundred); a filter applied by Jira guarantees the tickets of the wanted project are within what is read, not beyond it. When the cap is reached, the counter says so (“1000 of 2340 shown — cap reached”). The values on offer are the ones actually present in the loaded tickets, with the number of tickets for each — offering a value that brings back nothing helps nobody. The field picker and each value list have their own search; the values' one hides rows without unticking anything, so a selection is never lost by hiding. Several criteria combine with AND between fields and OR inside a field (“bugs and tasks, from this epic”). A criterion with no value ticked filters nothing: adding a field therefore never empties the list. The criteria are persisted.
  • The detail (on the right) shows the content (the Jira description converted from ADF into readable Markdown), every metadata field (status, type, priority, assignee, reporter, project, dates, due date, labels, components, fix versions), all the comments (author, date, body in Markdown) and the attachments — downloaded on demand through a server proxy that fetches the file with the token (a direct link would fail, since the Jira API requires auth). Plus an Open in Jira link.
  • Linked tickets are on the card. “is blocked by”, “duplicates”, “relates to”: those links are what says which part you cannot ship on your own, and seeing them meant reopening Jira. They now appear under the attachments, grouped by relation (five “is blocked by” make one label and five rows), each with its summary and its status — a key on its own teaches nothing. The relation wording is your instance's, in its own language, and it follows the direction of the link: Jira describes it from both ends, and flipping it (“blocks” instead of “is blocked by”) would be worse than saying nothing. Sub-tasks and the parent of a sub-task join the same list — a parent that is an epic stays in the details, where it already has its row. A done link is struck through: that dependency is lifted. The key opens the ticket here, in the column you are reading; the arrow opens it in Jira.
  • Code blocks stay code blocks. A technical ticket often puts a template inside a Jira table — a label on the left, JSON on the right. A Markdown table holds one line per cell: the code ended up flattened there, its indentation crushed and uncopyable. Such tables are therefore unfolded — each row becomes the label then its block, rows separated by a rule. You lose the grid, which was only a layout; you keep the content, which is what you came to copy. Ordinary data tables stay tables — and nothing in them is wrongly promoted to a title: only a row whose cells are all headers becomes one. A table with no header therefore keeps its first row, and a key/value table (header in the first column) keeps its first pair, the key in bold for want of a Markdown equivalent.
  • Changing a ticket's state asks first, naming the ticket and the state: a native <select> applies on change, so an arrow key was enough to move PROJ-1408 to “Done” in front of the whole team. The comment field sends on Ctrl/⌘ + Enter and keeps a draft that survives a reload; buttons insert the link of a known merge request at the cursor.
  • Watching a ticket can raise a todo when its state changes (a checkbox per ticket, unticked by default): a desktop notification dies with the tab, a todo stays in sight — and it carries the reason you wrote for watching. A watch that fails now says so instead of silently freezing.
  • An In Mergerie section. What the tool already knows about this ticket, without going to fetch it: the merge requests carrying its key (with their score and verification verdict) and the coding sessions started from it. The ticket list carries the same marker in one line, so you see at a glance which ticket is already under way in Mergerie and which one has nothing yet.
  • Let the AI code it from the ticket. The button at the head of the detail opens the coding session dialog already filled in: the ticket's content (title + description) is placed at the top of the prompt, the commit message and the branch name (feature/PROJ-1421-…) are proposed from the key and the summary, and the ticket number is filled in. All that is left is to pick the repository and to spell out your request under the context — the cursor is already there. The session is not launched automatically: you read it over first. The repository proposed is the last one used for that Jira project, and the ticket's screenshots are offered as checkboxes (the first three ticked): the images you keep are attached to the session, without a round trip through the Downloads folder.
  • Code outside a repo from the ticket. Next to it, opens an out-of-repo coding session (local folders, no repository or branch) pre-filled with the ticket and — if you wrote one — its technical brief. With or without a brief; nothing is launched until you do.
  • Change the ticket's state: a selector in the header lists the allowed transitions (what Jira lets you do on this ticket); picking one applies the transition and refreshes the status (detail + list). Nothing is offered if you do not have the rights.
  • Post a comment: a field at the bottom of the comments section — the text is converted to ADF (the format of Jira Cloud comments) server-side, and the new comment is appended to the thread without reloading everything.
  • Images are shown directly: image attachments get a fixed-width preview, and images embedded in the description or a comment are rendered inline where they appear (resolved through the proxy). A click opens the image large (lightbox; Esc or a click outside closes it). Other files stay as downloadable “chips”.
  • If Jira is not configured, a message points at Settings → Jira (URL + email + API token).

Watched

Follow a ticket without it being assigned to you — the common case: a ticket held by someone else blocks yours, and you want to know when it moves, not to think about it three times a day.

  • You add a ticket by its key (PROJ-1421) from this sub-tab, or with the Watch button at the head of a ticket's detail. The key is validated before any call: it never reaches the raw JQL.
  • The current state is recorded when you add it. Without that, the first check would compare against nothing and announce a change that never happened.
  • Say why you are watching it. An optional field next to the key — “blocks the billing migration”, “tell Sofia as soon as it is in review”. Three months later, a key and a summary no longer recall the reason. It is shown under the ticket's title and can be corrected at any time through the pencil on its row: going through remove/re-add would lose the date it was added and the last known state, and would trigger a false notification on the next pass. Clearing it is a legitimate choice — you do not keep a stale reminder. The field holds several lines (a reason rarely fits on one): Enter starts a new line, Ctrl/Cmd + Enter saves, Esc closes without changing anything.
  • A server timer re-checks every watched ticket at the rhythm set in Settings → Jira (Check watched tickets every N minutes; 0 = off). On every state change, a desktop notification gives the old and the new state — To do → In progress — and a click brings you back here. The type can be switched off in Settings → Notifications.
  • The ticket reads right here. Clicking a row of the list opens the ticket on the right, as under My tickets: description, metadata, comments, attachments — and the same actions (change the state, comment, Let the AI code it). It is the same panel, not a copy: watching a ticket without being able to read it forced you to open Jira for three lines of description. The card's own controls (remove, correct the reason) keep their own effect, and each sub-tab keeps its selection.
  • Check now triggers the very same code as the timer, immediately: what the button shows is therefore exactly what the watcher does.
  • A ticket that was deleted or became invisible (rights lost) is reported on its row, without interrupting the check of the others, and without erasing the last known state.

Finding the analysed tickets

The Analysed tab of the Jira menu lists every ticket whose technical brief was saved, started or proposed — with the repositories and branches read, its state (proposed, posted, to review…) and its version; a click opens the ticket and its brief next to the list, and the badge counts those with a proposal. An implemented ticket can be hidden from its row (the crossed eye) so the list does not grow forever: nothing is deleted, the badge and the count forget it, and the Show hidden tickets box (remembered) brings it back, dimmed and marked hidden, from where one click shows it again. Hiding is per workstation: what you tidy away does not vanish for your colleagues. In My tickets, the Analysis filter shows everything, only the tickets already analysed, or only those not analysed yet (the choice is remembered, and the list updates as soon as a brief arrives).

Stats — counting a set of tickets

How many bugs, how many user stories, how many user stories linked to a bug, and where does each status stand? The Stats tab answers over the set its filters describe — the same filters as My tickets (assignees, statuses, sprints, field filters, “Include done”), but independent: what you tick here does not touch the list, and the other way round. On the first visit Stats inherits the choices of My tickets, then each lives its own life.

  • The whole set, server-side. The counts are computed by the server, paging the Jira search up to 1,000 tickets (like the list) — beyond that the screen says so (“cap reached”) and invites you to narrow; the list's text search, on the other hand, does not enter the counts. Field filters go into the JQL (type, priority, labels, components, versions, epic); a reporter or an assignee ticked by name is turned into an account id — a name Jira cannot translate is ignored and said, rather than counted silently over a wider scope.
  • Four tiles: tickets, bugs, user stories, user stories linked to a bug (each share as a percentage, the last one as a share of the user stories) — and “other types” when there are any, hovering that tile naming those types. A user story is “linked to a bug” through any Jira link, in either direction, through a bug sub-task or a bug parent.
  • By type: each ticket type (Bug, Story, Task, Epic…) with its number, its percentage and a bar, the most numerous first — the whole breakdown, bugs and user stories included.
  • By status: the states in the workflow order of the projects involved (Backlog, then In progress, then Done…), each with its number of tickets, its percentage and a bar; a state without a ticket has no row, and a status carried by a ticket but foreign to the workflow follows. By assignee: the same per person, the most loaded first, “unassigned” apart.
  • An optional date range (“Moved from … to …”): count only the tickets that moved within the range, whatever the movement — created, updated (comment, edit, attachment…), or whose status, assignee, priority or resolution changed (what JQL keeps a history of). Whole days, in the Jira account's timezone; one bound is enough; the cross removes the range, and the choice is remembered.
  • Every number can be clicked — a tile, or the count of a row in the tables — and opens the list of the tickets it counts: key (link to Jira), summary, status, type, assignee. Nothing is asked of Jira again: everything was already read to count.
  • The time between two statuses — “how long from in progress to in production?”. Under the counts, two selectors: the start status and the arrival status (those the screen knows, workflow included), remembered. Jira does not keep that figure, it keeps each ticket's history: Mergerie reads, for every ticket that reached the second status — done ones included, without the status filter, with the screen's other filters —, the time from the first entry into the first status to the last entry into the second that follows it (a ticket picked up three times started the first time; a redone release is only shipped the second time). Four tiles — tickets measured, median (with min and max), mean, 90% in under — then by project, by type, and the list of tickets with both dates and their time in days. A ticket that arrived without going through the start, or went back to the start after its last arrival, is counted apart, never measured. With the date range: the tickets that reached the second status within the range. Cost: one more search, ten pages at most, the history travelling with each page (expand=changelog) — nothing until both statuses are chosen.
  • What it costs in Jira calls: a page of a hundred tickets is one call. The list and the stats make at most ten each (cap of 1,000); the values of the Stats filters come from a single page; the assignee list (six months of activity, ten pages at most) is cached for thirty minutes; a workflow's statuses are cached until the settings are next saved. And Jira's quota is honoured as Jira states it: at most four requests in flight, and on a 429 (or a 503 with a delay) Mergerie waits the requested delay (Retry-After, 30 s at most) and retries, three times; beyond that the screen says “Jira is rate-limiting calls” rather than a mute code.
  • What counts as a bug and as a user story is set in Settings → Jira (type names separated by commas, case-insensitive; by default Bug and Story, User Story): a type's name is free from one instance to the next (Defect, Récit…). It is a team decision, shared like the rest of the settings, and the screen reminds you at the bottom what it counted.

Technical brief of a ticket

A ticket written by a Product Owner says the functional what, never the where (which repositories, which modules) nor the how (the steps, the constraints of the existing code). The developer redoes that translation in their head for every ticket, and it lands nowhere. The "Technical brief" button of a ticket's detail opens the Technical brief section, where the AI does that work and proposes it as a comment.

  • What you give it. One or more repositories (the list filters as you type: the filter hides without unticking), each with its branch — a searchable list, the repository's default branch when you pick none: the code being described often lives on a release or a feature branch, and that is the one the AI reads (the "Have the AI code" session opened from the brief starts from it), the ticket's epic and its other tickets as context (ticked by default when the ticket has one — a ticket often makes sense in the light of its neighbours), one or several Confluence pages (five at most; Cloud is read with the Jira account, Server / Data Center needs an address and a token in Settings → Jira; a page that is not on that Jira or that Confluence is refused: credentials go nowhere else), a free complement ("it is the billing service, not crm; the legacy stays untouched"), the level of detail (summary, thirty lines at most, or detailed) and the box "The AI may ask me questions". Save without analysing keeps all of it (a repository is not required yet) and starts nothing: the ticket is marked to run, and the form comes back filled for you to launch the analysis later.
  • What it does. An ordinary exploration session, read-only, on the chosen repositories: it reads the ticket, its comments and linked tickets, the epic, the pages, then the code. Everything coming from Jira or Confluence enters the prompt as fenced data, never as an instruction; only your complement is read as one. A page that is refused (rights) or too long is said so, in the proposal and on screen, and blocks nothing.
  • Two kinds of questions. What only you know (which service, which convention) is asked before proposing, through the usual mechanism: the session goes to waiting for your answers, you answer in AI Dev, the analysis resumes. What only the PO knows becomes the proposal's last section, Open questions for the PO — often the first thing the PO reads.
  • The proposal. Six sections, always in the same order: Repositories involved, Existing code we build on (named files and modules, no code), What has to be done, Points of attention, Out of scope, Open questions for the PO. It shows up in the section without reloading the page.
  • Adjusting it. A follow-up ("detail the migration part", "too long") has the agent rewrite the whole proposal, in the same session; "Edit" opens it for hand editing, without calling the AI. Every pass is a version (AI, follow-up, edit), and the screen says when changes are not posted yet.
  • Posting. "Post as a comment" shows what leaves and asks for confirmation: the comment starts with a marker line (set in Settings → Jira) and the version number. Next time — new analysis, follow-up, touch-up — the button reads "Update the comment" and the same comment is rewritten, never a second one. If Jira refuses (the comment was posted by a teammate from another account, or the right to edit was removed), nothing leaves silently: the screen offers to post a new version under your name. Deleted on Jira in the meantime, a new one is created, and the screen says so.
  • To review. When the ticket changes meaning (title or description rewritten by the PO) after the analysis, the brief turns "to review" as soon as the ticket is opened. A mere status change expires nothing. "Run the analysis again" rereads everything (ticket, pages, code) in a fresh session; the versions and the posted comment stay.
  • Towards the code. "Start a session" opens the AI Dev modal prefilled: the brief's repositories as targets, the proposal as the instruction — the loop ticket → brief → session → MR.
  • A whole epic. "Brief the epic's tickets" lists its tickets, tickable (already briefed and done ones are unticked by default, a filter hides without unticking), and starts one analysis per ticked ticket with the repositories, pages and complement of the current form — the batch prepares in the background, the list chips follow. Each ticket then keeps its own brief: follow-up, edit, post, ticket by ticket.
  • In the list, every ticket carries a brief proposed / posted / to review / waiting for your answers chip. In AI Dev, the analysis session carries the Brief PROJ-123 tag (which opens the ticket), and a with / without / only ticket briefs chip hides those sessions in one gesture — remembered per machine, nothing archived; an analysis waiting for an answer stays visible whatever the filter.
  • Settings → Jira: address and token of a Confluence Server / Data Center, the comment's marker line, and team guidelines added to every analysis ("our endpoints follow /v2/<resource>", "never a destructive migration") — guidance, not protocol: the proposal's format itself is not editable.