Git Vertex VS Code Extension v1.32.0

Git Vertex VS Code Extension v1.32.0

Added

• What the model sees of a diff — per feature, and never a lie about it. Every prompt cut the same way: the first 6,000 characters. On a branch touching seven files that is the first four IN FULL, in git's alphabetical order, and nothing at all of the other three — the model was not shown less detail, it was shown a different change, and it described that one with the confidence of a whole reading. The cut is by file now, and whatever is cut the map stays whole: every prompt names every file that changed and by how much, then shares the budget across their bodies with a give-back, so one 26,000-character file cannot be the only one anybody reads. Each cut lands on a line boundary, says how many lines it dropped and of which file, and a file too small a share to carry a line of the change says it was not read rather than showing a header pretending to be content. Three levels, one control per feature in Settings › AI Assistant — Summary (the map alone, no bodies), Standard (the default, what everyone already had, now shared fairly), Complete (the whole diff, no ceiling) — for the four features that read one: commit message, explanations, pull request, split into commits. At Summary the model is told what it may not claim — it has the map, so it describes the shape of the change and says the commit messages are its only evidence, rather than answering a question about behaviour it has not read. Without that instruction it answered anyway: on a branch whose retry() had just stopped propagating its error, it called the change "safely managing execution failures", having seen src/retry.js +3 −6 and nothing else. Measured on one real branch: at Summary the model invented a retry behaviour the diff contradicts; at Standard it named the actual regression, in a small file the old cut dropped entirely. (#185)
• Reply length, per feature. Every AI call carries a ceiling — 512 tokens for a commit message, 8192 for a conflict resolution — and until now they were invisible constants nobody could change. They are one control each in Settings › AI Assistant: Standard, Generous, Maximum. (#183)
• The AI reads more than a commit. A branch, a stash and the uncommitted work can all be explained now — the same reading the commit panel has offered since v1.10, on the three diffs that had nowhere to ask for it. The branch is read against a base worked out rather than assumed: the trunk the remote declares, the remote's copy of it over a stale local one, and its own upstream when the branch asked about is the trunk. Every answer opens in the composers' drawer, breathes while it waits, writes itself in word by word, and takes a focus — only the migration — for another go. (#70)
• A changelog, from the branch menu — written once, then kept. What a branch adds over its base, grouped under ### Added / ### Changed / ### Fixed — the sections this file uses — with the empty ones forbidden rather than tolerated. It is remembered: reopening the drawer costs nothing and shows what was written, with when. When the branch has moved on it says so — 3 commits since — this changelog does not cover them — and Update extends the text rather than rewriting it, so the bullets you already reviewed stay word for word. Insert into changelog puts it where changelogs live: the repository's own file, under its Unreleased section, merged into the headings already there rather than as a second ### Added, never adding the same bullet twice and never removing a line. No changelog file yet ⇒ one is written. And it decides nothing on your behalf: it shows you what would go in, before anything does — the exact lines, the ones already there word for word that it will skip, what the target sections already say so you can compare, and a warning when the file has uncommitted changes (a changelog is written once and inserted later, into a file that has moved on). It follows your changelog's shape rather than a template's. The section for unreleased work is found under any of the names one goes by — Unreleased, [Unreleased], Next, Upcoming, master, À paraître and a dozen more — and the entry's own headings are re-levelled to sit inside it, so a file whose releases are # gets ## groups rather than ### ones. When a file keeps no such section at all, nothing is invented: it asks where these lines go, offering the file's own headings and the option of a new section — which it then writes at the file's own heading level. Regenerating and inserting again replaces what it wrote rather than doubling it — the model rewords everything on a second pass, so no verbatim check would ever catch that; the lines of the previous insert are remembered and taken back out. One of them edited by hand in the meantime is left exactly where it is, and the preview says so: written once does not mean owned for ever. And it knows what each changelog is about. One in cli/ describes the CLI: if the branch changed nothing under cli/, there is no entry to write there and it says so — no preference can make an empty entry true. If the branch touched both that directory and elsewhere, it asks what the entry should cover, everything the branch carries or only what changed under cli/, and the second generates a different entry from that directory's commits alone. The answer is kept in the repository's own git config beside gitvertex.defaultRemote, and restated in the same question every time with the alternative one click away: a remembered answer that is applied silently is worse than a setting, because a setting can at least be found. It also asks which file, and finds them all: every tracked changelog at any depth, so a repository shipping four products sees its four rather than only the one at the root. All N of them is one of the answers — one change that touches the app and the extension belongs in both, and what was written is remembered per file, so regenerating replaces its own lines in each. It stops on a branch that has been merged or deleted since, where those bullets are presumably already in there. (#70)
• A commit composer. The uncommitted work, cut into a sequence of atomic commits and reviewed before any of it is history: edit a message, move a file between commits, reorder them, drop one, add one. Whole files, staged or not — and the drawer says so. Every path the model names is checked against the tree: an invented one is dropped and counted, a file it placed nowhere is shown rather than quietly left behind, and a failure halfway says how many commits were made and that the rest is still on disk. (#70)
• The VS Code panel gets all of it. The readings the desktop shows in a drawer open as editor tabs there — the panel is narrower than the answers' own paragraphs, and this extension already opens the staging editor, the rebase planner and a comparison that way. Same component, same calls, a different frame: explain a branch, a stash or the uncommitted work, write a changelog (insert included, with VS Code's own prompts for the two questions and the preview), and cut the working tree into commits. The activity rail's robot head is now the AI view and holds all of it — what the model has written for this repository, and the agents running in it, which were a second robot head of their own. (#70)
• Which repository, which branch, and whether that branch is heading for a fight — all three on the toolbar. The repository selector left the top 47px of the left panel (a full-width header above every list, in the one place where height is scarce) for the toolbar's left edge, which was empty. Beside it, a branch picker with a filter, local branches first, remote ones below — picking one goes there, creating the tracking branch if that is what it takes. And beside that, the conflict outlook: a quiet badge that says No conflicts detected against origin/main, or counts the files that would conflict, measured with merge-tree against the same base the AI features read a branch against. It never blocks anything, it fails open — an error means "we do not know", never a warning — and clicking it says what it means: what was simulated, against what, which files would clash, and that nothing was merged.
• A merged branch is not a lost one. A kept reading — an explanation or a changelog — was struck through the moment its branch stopped resolving, which meant it was struck through on the day the branch merged and was pruned: the ordinary, successful end of a branch, marked as a loss. The row asked whether the name still existed; it asks the commits now. A branch whose work landed says in main and keeps its ink; only a branch force-pushed away — or a stash actually dropped, which the stash list is asked about rather than rev-parse, since a dropped stash's commit still resolves for hours — is struck through. And every row that still has commits to point at wears a chip with their count: click it and the graph highlights exactly what that reading covered, which is the answer to "the branch is gone, so what was this about?". A branch reading now remembers the base it was read against, so the range survives the branch; readings kept before that point at their tip. Forget what is gone sweeps up the lost ones only. (#70)
• A second stack in the panel: everything the model has written here. A strip above the repository list chooses between List — everything it has always shown — and AI. That stack holds the changelogs written for this repository and every explanation kept: a branch, a stash, the uncommitted work, and the commit explanations the panel has been storing since v1.10 that nothing ever listed. Each row says what it covers and when, wears +3 when its subject has moved on since, and strikes itself through when what it described is gone — a dropped stash, a deleted branch. A row reopens the reading without asking the model again; right-clicking forgets it. Generating anything brings the stack into view with the new entry already in it, rather than leaving it to be discovered. The VS Code panel gets the same view on its rail. (#70)
• An AI row now looks like one. Every entry that reaches a model wears the mark and is written in the ink this app reserves for what a model proposes, and the submenu the branch menu's AI row opens is outlined in the dashes that go with it. "AI" as a bare word was one more verb in a list of twenty, and nobody found it; the labels drop their now-redundant "(AI)" suffix.
• Two more features in Settings › AI Assistant — changelog generation and splitting into commits — each with its own model and its own standing instructions, like the seven before them.

Changed

• Resizable columns for short panels. The graph, changed files and commit form sit side by side when the bottom panel is short and wide enough, using the existing extension theme and controls. Drag either divider, or focus it and use the arrow keys, to give long filenames more room or shrink the file column. Compact widths survive reloading and stay separate from the taller layout. Hide graph temporarily gives all available width to the files and commit form; secondary file and commit actions remain available in menus.
• The keyboard reaches the menus and the rebase. A context menu could only be walked with the mouse: arrows move over its enabled rows now, Right opens a submenu on its first entry, Left comes back, Enter acts, Escape leaves, and the menu holds the focus while it is up and gives it back on close. The rebase editor's rows have two arrows each, and Alt+arrows on a focused row, where before there was only drag-and-drop — and the editor says what the plan comes to before it runs: Rewrites 12 commits into 9: 2 folded into another, 1 dropped, 3 reworded.

Fixed

• Files and Commit no longer disappear in a short bottom panel. The compact layout gives the file list its own scrolling area and keeps the commit button below the message, including at minimum column widths and very small heights. Long filenames are truncated without pushing actions outside the panel.
• Enter on Cancel no longer confirms. A confirmation listened for Enter on the whole document and answered yes whatever had the focus — Tab to Cancel, Enter, and the branch was deleted anyway. Enter now activates the button that has the focus and nothing else. A destructive question opens with the focus on Cancel, an ordinary one on Confirm; Tab stays inside the box, Escape closes it, and closing gives the focus back to what opened it. The box is announced as a dialog, named after its question.
• A commit message survives a look at the history. The message lived in the form, and the form was unmounted the moment you selected a commit. A draft is kept per repository now, saved as you type, restored when you come back and after the panel reloads, and cleared only by a commit that succeeded. The amend message is kept apart from the ordinary one, and an amend armed for a commit that is no longer HEAD disarms itself rather than rewriting the wrong commit with an old message.
• Two comparison tabs no longer show the same comparison. Every comparison has its own view now, keeps the references and the axis you changed in it, and the picker shows a commit hash as a real choice instead of choose a reference. Hashes are shown short wherever they are named.
• A diff git could not read no longer reads as "No differences". Every diff method answered { diff: '' } to a failure as well as to an empty change. The reason travels now, the file diff and the comparison say it, and each has a Retry.
• Four icons drew their SVG percent-encoded. The webview build declared its file loaders twice, and the second copy — SVG as a data URL — silently won over the first, which the icon component needs: it parses the SVG's text and got %23 where a # was. One declaration now, and the build refuses a bundle that carries an SVG as a data URL. The panel also stopped declaring itself French to screen readers.
• A request the model refuses for size now says which control fixes it. It used to arrive as the provider's own words — Request too large for model x in organization org_01ksn… service tier on_demand on tokens per minute (TPM): Limit 8000, Requested 10013 — which names an organization id, a service tier and a unit nobody chose, and not the one thing that caused it. Worse, the retry loop then sent the same oversized request twice more, half a second apart: three certain failures where one was already certain. It is read now, across all five providers' wordings, and answered with the numbers in figures and one control — set What the model sees to Standard for this feature — the value below whatever it was sent at, or a plainer this needs a model with more room when it is already at the bottom and there is nothing left to send less of. A feature carrying no diff is never sent to a diff setting. The provider's own words are kept, minus its billing upsell. An ordinary rate limit is not read as this and keeps its retries — waiting is what fixes that one. (#185)
• A model that thinks before it writes no longer fails silently. A reasoning model spends its budget reasoning, so a ceiling calibrated for one model can cut another off before it emits a single character — and the app called that "the model returned an empty response after 3 attempts", indistinguishable from a bad key. All three provider dialects say when they ran out of room (finish_reason: length, stop_reason: max_tokens, finishReason: MAX_TOKENS) and all three were thrown away. Now a truncated answer is retried with more room rather than with the same, what worked is kept in that feature's own control — a correction made on your behalf is one you can see and undo — and an answer that still will not fit says exactly that, naming the model and the number. (#183)
• The ceilings lived in two copies, one per product, free to drift as the prompts once did. One table now, read by both. (#183)

---

Installe le VSIX directement :

code --install-extension git-vertex-1.32.0.vsix

Ou cherche Git Vertex dans le Marketplace VS Code.

🔗 VS Code Marketplace
🔗 Open VSX