Skip to content
| Marketplace
Sign in
Visual Studio Code>SCM Providers>jw-differNew to Visual Studio Code? Get it now.
jw-differ

jw-differ

jwilenius

|
1 install
| (0) | Free
IntelliJ-style Git commit diff viewer and three-way merge conflict resolver for VS Code
Installation
Launch VS Code Quick Open (Ctrl+P), paste the following command, and press enter.
Copied to clipboard
More Info

jw-differ

[!NOTE] This was 100% vibe-coded, but the vibes were heavily curated; Claude on a leash.

jw-differ is short for "just-working-differ" or "jim-wilenius-differ" — take your pick.

IntelliJ-style Git commit diff viewer and three-way merge conflict resolver for VS Code.

Two workflows: review the combined changes of any set of commits, and resolve merge conflicts.

Git commit history and diff viewing

Select any subset of commits — including non-adjacent ones — and see exactly what those commits change, with nothing from the commits in between. Double-click a file to open its diff in VS Code's native diff editor.

jw-differ Git History panel below an open two-way diff of src/inventory.ts

Git History panel: branch graph, commit table, changed files, replay order and details; the selected commit's diff open above.

Git History panel with two commits from different branches selected and a pinned base, below the diff of src/inventory.ts against that selection

Multi-commit selection: two non-adjacent commits on different branches, Ctrl+clicked, replayed onto a pinned base; the diff shows only their changes, nothing from the commits between them.

Opening it

The jw-differ history button in the Explorer's folder header The jw-differ history button in Source Control's Changes header

The jw-differ history button in the Explorer's folder header (left) and Source Control's Changes header (right).

  • Click the jw-differ button (two panes joined by a ribbon) in the Explorer's folder header or the Source Control header (Git repositories), run jw-differ: Open Git History, or open the jw-differ tab in the bottom panel. jw-differ: Refresh Git History (also the ↻ button in the view title) reloads commits and refs.
  • The header buttons open the bottom panel and leave the side bar alone: it keeps showing the Explorer or Source Control. jw-differ adds no Activity Bar icon. Like other buttons in a section header (the Explorer's folder, or Source Control's Changes on newer VS Code), they show while the pointer is over the side bar unless workbench.view.alwaysShowHeaderActions is on.
  • The repository comes from the active editor and the workspace folders; the picker switches between them, and Open… adds any local repository folder. Each repository keeps its own selection and base for the session.
  • The status bar shows <repository>: N selected · base … and reopens the panel when it is hidden. Hiding and reopening the panel keeps the selection, base and filters.

Selecting commits

Layout follows IntelliJ's Git Log: branch graph and commit table (subject, branch/tag labels, author, date, hash) on the left; changed files, replay order and commit details on the right.

Gesture Effect
Click Select only that commit
Ctrl/Cmd+click Add or remove one commit
Shift+click Select the shown range from the last clicked commit
Ctrl/Cmd+Shift+click Add that range to the selection
↑ / ↓ Move focus; details update when you pause
Shift+↑ / Shift+↓, Space Extend the selection / toggle the focused commit
Clear Deselect everything
Double-click or Enter on file Open its diff (base ↔ result) in the editor
  • Search filters by subject or hash (literal, case-insensitive); the branch filter shows commits reachable from that branch. Filtering never changes the selection — selected commits it hides are counted next to the selection.
  • The branch filter starts on the checked-out branch (each worktree's own) and follows HEAD on every refresh until you pick one: a new commit, or checking out another branch, moves it along. It shows all branches while HEAD is detached or older than the loaded commits. A branch you pick, or All branches, is kept across refreshes and repository switches and follows that branch as it moves; if the branch is deleted or no longer loaded, it shows all branches.
  • The table shows 200 commits at a time; Load more adds 200.
  • The panel loads at most jwDiffer.historyMaxCommits commits (default 20,000, minimum 100): the newest ones by commit date across local and remote branches, tags and a detached HEAD; the table then lists them in date order rather than topological order. When older history is left out, the status line and the end of the table say "Showing the newest 20,000 commits", and graph lines to parents that were not loaded end in a short dashed stub. Changing the setting reloads the panel. Larger values make loading and searching slower and use more of the extension host's memory.
  • The graph draws at most 16 lanes. Commits on later lanes share a 17th overflow column with a dimmed dotted marker, and lines into it fade out at its edge; hovering such a row's graph explains this.

Comparison base

  • Automatic (default): the parent of the earliest selected commit, or the empty tree when that is the root commit. The ancestry decides "earliest", not table order or dates. The toolbar shows the resolved hash and subject.
  • When the selection has several earliest commits that are not ancestors of each other (for example commits on two branches), jw-differ asks for a base: type a commit, branch or tag and press Pin. A pinned ref is resolved once and stays on that commit even if the branch later moves; Automatic unpins it.
  • A selected merge commit gets a parent selector in the replay list (default: first parent). Its changes are taken relative to that parent, and the choice also moves the Automatic base when the merge is the earliest commit.

What is compared

  • jw-differ replays only the selected commits' own changes (each against its parent) onto the base, oldest first, in Git's topological order. The replay order is listed in the panel.
  • The file list shows the net change from base to result: additions, deletions, modifications, renames, mode changes, binary files and submodules. Changes that cancel out disappear; if everything cancels, the panel says so.
  • The file shown in the diff view is marked in the list with the selection colour and a bar on its left, and the mark follows F7 / Shift+F7 to the next or previous file, scrolling it into view. Closing the diff tab, or a selection that no longer lists the file, clears the mark and the row's focus.
  • If a selected commit depends on a commit you left out and cannot be applied, replay stops at that commit and lists the conflicting paths. No partial result is shown; change the selection or base and it retries.
  • Example: on A ← B ← C ← D, where B adds b.txt, C adds c.txt and D adds d.txt, selecting B and D compares against A and shows only b.txt and d.txt.
  • Opened diffs are snapshots: changing the selection later does not alter a diff that is already open.

The diff view

Files open in an IntelliJ-style side-by-side diff rather than VS Code's padded one:

Two-way diff of src/inventory.ts with added, modified and changed-word highlights

One commit's changes to src/inventory.ts: added lines green, modified lines blue with changed words darker.

  • No filler rows. Each side shows only its own lines; inserted lines are one green block on the new side and a thin line between the rows of the old side, joined by a curved band. Deleted lines are grey, modified lines blue with the changed words in a darker shade.
  • Both panes scroll together, keeping corresponding blocks level; ↑/↓ (or F7 / Shift+F7) jump between differences, and the difference jumped to is outlined in the focus colour on both sides, with its band, as the current one.
  • F7 at the last difference shows "Press F7 again to go to the next file"; pressing F7 again within 2.5 s opens the next file of the panel's Changed files list (same comparison) at its first difference. Shift+F7 at the first difference does the same towards the previous file, landing on its last difference. Files with no text difference to show (binary, too large, not UTF-8, rename- or mode-only) are skipped; at either end of the list the hint says "No more files" / "No previous files". The ↑/↓ buttons stay within the file, and the built-in diff editor keeps VS Code's own F7.
  • Ctrl+F (Cmd+F) opens VS Code's find widget over both sides, off-screen lines included (not the line numbers); Enter / Shift+Enter go to the next / previous match, Escape closes it and returns the keys to the diff.
  • F4 opens the file from your working tree, editable in a tab of its own, with the cursor at the current difference (or the top visible line once that is scrolled away). The line follows later commits and unsaved edits to wherever it is now, or the nearest line if it is gone. A file deleted on the right side, or since deleted or renamed in the working tree, gets a short message instead. F4 elsewhere in VS Code is unchanged.
  • Syntax colouring uses the grammars of your installed VS Code extensions and the active colour theme (including editor.tokenColorCustomizations → textMateRules), and follows theme changes. Semantic colouring from language servers is not applied, so some identifiers can differ slightly from the editor. Files over 500 000 characters, or that take more than about 2 seconds to colour, are shown partly or wholly uncoloured.
  • Open in VS Code diff shows the same comparison in the built-in diff editor. Set jwDiffer.historyDiffViewer to native to always use it. Opening another file reuses the same tab.

Limits

  • Read-only: no checkout, staging, commits, ref changes or hooks; the working tree and index are never touched. Replay runs in a private temporary repository that borrows the source's objects and is deleted afterwards.
  • Local repositories only; no network fetches. Shallow clones load, but a comparison that needs history beyond the shallow boundary fails until you deepen the clone with Git.
  • Files that are binary, not valid UTF-8, or over 16 MiB open as an explanation (type, size, mode) rather than a text diff. History beyond jwDiffer.historyMaxCommits is not loaded, so it cannot be selected or searched; a history whose commit list exceeds 64 MiB of Git output still fails to load.

Merge conflict resolution

IntelliJ's merge dialog: your branch on the left, the editable result in the middle, the incoming version on the right, joined by connector ribbons.

Three-pane merge view of src/inventory.ts with connector ribbons and gutter buttons

src/inventory.ts mid-merge: main left, result middle, feature/sku right; 7 changes, 4 conflicts.

Opening it

  • jw-differ: Resolve Conflicts lists the conflicted (unmerged) files of every repository holding a workspace folder or the active editor; pick one to open it. Only text conflicts are listed: both sides present, every stage a regular file. Modify/delete, symbolic-link and submodule conflicts are left to git.
  • Every stage must be UTF-8 text without NUL bytes. A binary or non-UTF-8 (e.g. Latin-1) conflict is still listed, but opens a page saying why it cannot be merged rather than corrupting its characters. A UTF-8 byte order mark is dropped from the stages and merged on its own (a side that added or removed it wins). Apply writes it once: VS Code saves the mark of a file opened with one; otherwise, as after a conflict on line 1, the mark leads the written text.
  • jw-differ: Open Three-Way Merge View, or the merge button in the title bar of a file with conflict markers, opens the active file.
  • Resolve Conflict in jw-differ in the right-click menu of a conflicted file opens that file: in the Explorer, on an editor tab, and in Source Control's Merge Changes. The Explorer and tab entries track the files the picker lists (including their paths through a workspace folder opened via a symbolic link); the list refreshes on activation, on window focus, on workspace folder changes, when the Git index of a repository it covers changes (including an index outside the workspace folder: a linked worktree's, a submodule's, or that of a repository above the folder), and when a merge view closes. The Source Control entry shows on every file under Merge Changes, as VS Code gives that menu no file path to test; on a conflict jw-differ cannot merge, such as a deleted side, a symbolic link or a binary file, it says why.

jw-differ: Resolve Conflicts QuickPick listing README.md and src/inventory.ts

jw-differ: Resolve Conflicts lists the conflicted files.

Panes

Pane Content Source
Left Your branch's version git stage 2 (:2:<path>)
Middle The result, starting as the common ancestor (no markers) git stage 1 (:1:<path>)
Right The incoming version git stage 3 (:3:<path>)
  • Add/add conflicts have no stage 1; the result starts empty.
  • During a rebase git's sides are reversed; the toolbar warns.
  • The result lives in the view until Apply; the file on disk is untouched until then. Apply refuses to write a file that has become a symbolic link. The check runs just before VS Code saves the file, not atomically with it: a link another process puts in place in between is followed, as VS Code's save always does.

Changes and conflicts

Each side is diffed against the base. A change is a block only one side touched; a conflict is a block both sides touched differently. The toolbar reports N changes. M conflicts., then All changes have been processed.

Colour Meaning
Red Conflict — both sides changed the block
Blue Modified — the side changed base lines
Green Added — the side has lines the base lacks
Grey Deleted — the base has lines the side lacks
None Unchanged, or that side is already processed

Lines get a soft tint; gutters, ribbons and changed words a stronger shade. Light and high-contrast themes have their own palettes; all of them can be changed (see Customizing colours).

The same merge view in the Default Light Modern theme

The same merge under Default Light Modern.

Resolving

  • » / « in a side's gutter applies that side's block to the result; × ignores it. Each side of a block is decided separately: applying both sides of a conflict keeps both, in the order they were applied.
  • Apply non-conflicting changes: (toolbar) applies every pending non-conflicting change from the left, the right, or both.
  • Accept Left / Accept Right (footer) replaces the whole result with that side's version, discarding edits.
  • Apply writes the result to the file and saves it; when every block is resolved it also stages the file (git add). Unresolved blocks ask for confirmation first. Cancel discards the view's edits, after confirmation if there are any.

Merge view partway through resolving, with an edited result line

Partway through: the first conflict takes both sides, the left's console.debug is applied, the right's findItem change ignored, result line 26 edited; 5 changes, 3 conflicts left.

Editing the result

Key Effect
Any text Edits that result line (debounced 400 ms)
Enter Splits the line, replacing any selected text
Backspace at col 0 Joins onto the line above
↑ / ↓ Moves between result lines, keeping the column
Shift+↑ / Shift+↓ Extends the selection to the line above / below
Text, Backspace, Delete, Enter over a multi-line selection Replaces it, as one undo step
IME composition over a multi-line selection Removes it as one undo step, then composes there
Ctrl+X (Cmd+X), Shift+Delete over a multi-line selection Cuts it, as one undo step
F7 / Shift+F7 Next / previous unresolved block (also ↓/↑ icons)
Ctrl+F (Cmd+F) Finds text in all panes (VS Code's find widget)
Ctrl+Z (Cmd+Z) Undoes the last edit or resolving action
Ctrl+Shift+Z (Cmd+Shift+Z), Ctrl+Y Redoes it

Undo and redo redraw the page with the caret where the step changed the result; a step that left the result as it was, such as undoing an ignore, leaves no caret.

Ctrl+Z / Ctrl+Shift+Z (Cmd on macOS) and Undo and Redo from the Command Palette always work in the merge view. Edit → Undo and Redo from the menu bar work only with the native title bar ("window.titleBarStyle": "native"); each drawn page gives the webview one hidden step of each, so they reach the merge's history on a freshly drawn page too. With the custom title bar, VS Code moves focus to the menu bar before running the command, so it never reaches the merge view; no stable extension API can route it (verified in VS Code 1.90 and 1.146).

Scrolling is synchronised across the three panes, aligned on the blocks.

Customizing colours

The change colours of the two-way diff and the merge view are theme colours: each has a default per theme kind, and workbench.colorCustomizations in settings.json overrides them for every theme or, under "[Theme Name]", for one theme. Open views repaint when the setting changes. Colour themes can set the same ids in their colors.

Id Paints Dark Light High contrast
jwDiffer.diffAddedBackground Two-way diff: added lines (green), their line numbers and ribbons #2f4337 #e3f3e6 #1b3323
jwDiffer.diffDeletedBackground Two-way diff: deleted lines (grey), their line numbers and ribbons #484a4a #ebebeb #3a3a3a
jwDiffer.diffModifiedBackground Two-way diff: modified lines (blue), their line numbers and ribbons #28323d #e6eefb #1b2a3d
jwDiffer.diffModifiedWordBackground Two-way diff: changed words inside modified lines #3e546e #c5d7f5 #2e5788
jwDiffer.mergeConflictBackground Merge: conflict lines (red) #241f1f #fff0ec #3d2421
jwDiffer.mergeConflictStrongBackground Merge: a conflict's gutters, result line numbers, ribbons and words #312623 #fbd4ca #6b3a33
jwDiffer.mergeAddedBackground Merge: added lines (green) #25322a #e3f3e6 #1b3323
jwDiffer.mergeAddedStrongBackground Merge: an added block's gutters, result line numbers and ribbons #25322a #c9e8cf #2b5537
jwDiffer.mergeDeletedBackground Merge: deleted lines (grey) #363737 #ebebeb #3a3a3a
jwDiffer.mergeDeletedStrongBackground Merge: a deleted block's gutters, result line numbers and ribbons #363737 #d6d6d6 #555555
jwDiffer.mergeModifiedBackground Merge: modified lines (blue) #222930 #edf3fd #1b2a3d
jwDiffer.mergeModifiedStrongBackground Merge: a modified block's gutters, result line numbers, ribbons and words #2f3d50 #c5d7f5 #2e5788

High contrast light themes use the light defaults. Values are hex colours (#RRGGBB). Use opaque colours: the gutters and line numbers stay in place while the code scrolls sideways beneath them, so a translucent value (#RRGGBBAA) lets that code show through and tints the line numbers twice.

// settings.json
"workbench.colorCustomizations": {
  // Every theme: added lines in the two-way diff.
  "jwDiffer.diffAddedBackground": "#2e5a3a",
  // Light Modern only, winning over the entry above: a light green, stronger merge-conflict reds.
  "[Light Modern]": {
    "jwDiffer.diffAddedBackground": "#c9f0d2",
    "jwDiffer.mergeConflictBackground": "#ffd9d0",
    "jwDiffer.mergeConflictStrongBackground": "#f5a898"
  }
}

Typing jwDiffer. inside workbench.colorCustomizations lists the ids with their descriptions.

A [<theme>] key must name the theme as the running VS Code does. VS Code 1.146 names its built-in themes Light Modern, Dark Modern, Light+, Dark+; older releases such as 1.90 name them Default Light Modern, Default Dark Modern, Default Light+, Default Dark+. VS Code 1.146 still accepts the old names in workbench.colorTheme, but not in [<theme>] keys.

Architecture

The merge and history logic know nothing about VS Code or HTML, so a second front end — a TUI — only has to supply a renderer. src/test/layering.test.ts asserts these boundaries rather than trusting them.

src/core/    line and word diff, conflict-marker detection     (pure, no I/O)
src/git/     merge sources, conflicted files; history reads, replay, file content (pure Node)
src/model/   merge session + view models, history controller — renderer-agnostic   <-- the seam
src/render/  html/ renderers for the merge, diff and history webviews
src/host/    VS Code wiring: webview panels, commands, message validation
Port / seam Contract
mergeSession Immutable MergeState: startMerge, applySide, ignoreSide, applyNonConflicting, acceptSide, editLine, splitLine, joinWithPrevious, tallyMerge
describeMerge MergeState → per-block view (tint, side ranges, resolutions, changed words)
HistoryRepository loadHistory, resolveRef, compare, readFile, releaseSnapshot (Git adapter port)
HistoryController load(), setSelection(oids), setBase(ref), setMainline(oid, parent), compare()

Install from GitHub Releases

  1. Open Releases.
  2. Download the jw-differ-<version>.vsix file under Assets.
  3. In VS Code, run Extensions: Install from VSIX... and select that file, or run code --install-extension jw-differ-<version>.vsix.

Requires VS Code 1.90 or later; tested with VS Code 1.90 and 1.146.

Upgrading from Differ or local.jw-differ

The extension id is now jwilenius.jw-differ (publisher jwilenius); earlier builds used local.differ (Differ) and local.jw-differ. VS Code treats a different id as a different extension: uninstall the old one before installing this one. The publisher change does not affect command, view, setting or colour ids. From Differ, command, view, context key, setting and colour ids moved from differ.* to jwDiffer.*; update keybindings (including when clauses such as differ.hasConflicts), settings.json entries such as differ.historyDiffViewer, and workbench.colorCustomizations that use the old ids. Moved or hidden jw-differ views start in their default places.

Release

Releases are automatic. Every push to main runs Build and release VS Code installer: lockfile malware and high-severity advisory checks, locked install without install scripts, registry signatures, install scripts, typecheck, tests. A missing-key signature error is retried once, with a fresh npm cache, against registry.npmjs.com (scripts/check-signatures.sh): registry.npmjs.org CDN edges can serve stale attestation documents, and the .com alias of the same registry is not CDN-cached. A failed signature check also logs registry keys, the failing package's attestations and npm's cached Sigstore TUF keys, and uploads npm's debug logs as artifact npm-signature-check-logs. When all pass, scripts/next-release-version.mjs reads the Conventional Commit messages since the last release and picks the bump; the highest bump wins:

Commits since the last release Release
<type>!: or <type>(scope)!: on any type, or a BREAKING CHANGE: / BREAKING-CHANGE: footer major (also from 0.x: 0.4.0 → 1.0.0)
feat: / feat(scope): minor
fix: / fix(scope): patch
only docs, test, chore, style, refactor, perf, ci, build or non-conforming none: the run builds a development installer
  • Types are case-insensitive (Feat:); the footer must be upper case at the start of a line after the header. Only the header sets the type: a squashed body listing feat: lines does not. A non-conforming header (Add search, Merge branch 'x', Revert "...") never releases, even with a breaking footer. Merged branches' commits count.
  • Last release: the highest vX.Y.Z tag reachable from the pushed commit. Without one, the package.json version counts as the last release and the whole history is scanned, so the first release is one bump over that version. With a tag, package.json must hold its version, or the run fails: never edit the version by hand.
  • Dry run: node scripts/next-release-version.mjs prints the next version (or nothing) on stdout, the reason on stderr.
  • A release run sets the version in package.json and package-lock.json, packages jw-differ-X.Y.Z.vsix, commits chore: release vX.Y.Z as github-actions[bot], creates annotated tag vX.Y.Z, pushes both atomically (--atomic), then publishes a GitHub Release with the installer and generated notes. Only the tag and publish jobs can write to the repository; they run no dependency code. The version is decided before any dependency code runs.
  • Pull after a release: CI commits to main, so git pull (--rebase with local commits) before pushing again.
  • The release commit and tag start no run: pushes made with GITHUB_TOKEN trigger no workflow, and chore: never releases.
  • Runs on main queue and never overlap; a release in progress is never cancelled; a newer push replaces a run still waiting. If main moves during a run, the atomic push fails without changing either remote ref and the run fails; the run for the newer push releases the same commits. If that push skipped CI, no run retries: use Run workflow.
  • Skip a run: [skip ci] in the pushed head commit's message (no checks, no installer); its commits still count toward the next release, which waits for the next run. Retry: Run workflow on main decides again from the current main; on another branch it only builds a development installer. If only the publish job failed, Re-run failed jobs publishes the existing tag. A release cannot be forced without a feat, fix or breaking commit.
  • Repository settings: github-actions[bot] must be able to push to main and create v* tags. Branch protection or rulesets that require pull requests, status checks or signed commits on main, or that restrict v* tags, reject the push unless GitHub Actions may bypass them.

Marketplace publishing

Manual promotion of an existing GitHub Release; nothing is rebuilt.

  • Promote: scripts/publish-marketplace.sh X.Y.Z (or vX.Y.Z; needs gh, authenticated). It fetches tags, then checks: release tag vX.Y.Z on origin; no vscode-vX.Y.Z locally or on origin; X.Y.Z above every vscode-v* tag on origin (the Marketplace accepts only increasing versions); GitHub Release vX.Y.Z has jw-differ-X.Y.Z.vsix. It then creates annotated tag vscode-vX.Y.Z on the release commit (not HEAD) and pushes only that tag. Pushing the tag by hand works too.
  • The tag push runs Publish to VS Code Marketplace (publish-marketplace.yml), which checks: tag is vscode-vX.Y.Z (plain X.Y.Z); vX.Y.Z exists on the same commit; release asset jw-differ-X.Y.Z.vsix downloads; its packaged extension/package.json is jwilenius.jw-differ at X.Y.Z (releases up to v0.5.0 carry publisher local and are rejected). Then the dependency checks of the build (check:deps, npm ci --ignore-scripts, check:signatures) and vsce publish --oidc --packagePath with the locked @vscode/vsce.
  • Authentication: Marketplace Trusted Publishing (GitHub OIDC, no PAT). The Marketplace exchanges the job's OIDC token for a credential valid 15 minutes. Policy on publisher jwilenius: owner jwilenius, repository differ, workflow publish-marketplace.yml, environment marketplace; renaming any of them breaks publishing until the policy matches.
  • Repository settings: environment marketplace with deployment branches and tags limited to tag pattern vscode-v*. Optional: a tag ruleset on vscode-v* that restricts creation to maintainers, since creating the tag publishes.
  • Do not promote v0.5.0 or earlier (publisher local). The dependency checks read the release's lockfile at promotion time: a newly published high-severity advisory blocks promotion until a newer release.
  • A failed run can be re-run; a version already on the Marketplace fails the publish step. To drop a promotion that cannot succeed, delete its vscode-vX.Y.Z tag locally and on origin: it otherwise counts as promoted.

Install a development build

Every push to main that does not release builds a development installer after the checks pass; a release run keeps its release installer instead. Manual builds are also available.

  1. Open Build and release VS Code installer.
  2. Select a successful run and download the jw-differ-vsix artifact (retained for 30 days).
  3. Extract the ZIP to get jw-differ-main-<commit>.vsix, named by its 7-character commit hash so it never clashes with a release installer. Its internal version is still the last release's.
  4. In VS Code, run Extensions: Install from VSIX... and select that file.

For a local installer, use Node.js 22, run npm ci, then npm run package.

Build and test

Project-local Node.js (version in .node-version; npm included), signature- and checksum-verified into .node/: scripts/install-node.sh, then export PATH="$PWD/.node/bin:$PATH".

npm install         # deps
npm run build       # bundle to dist/extension.js
npm run watch       # rebuild on change
npm run typecheck   # tsc --noEmit
npm test            # vitest, core + view model
npm run check:deps  # lockfile: npm audit (high+) and OSV malware advisories

Tests run Git with only src/test/fixtures/gitconfig and no inherited GIT_* variables (src/test/gitTestEnvironment.ts), so machine or user Git configuration cannot change results.

The Dependency check workflow reruns check:deps and the registry signature check every Monday at 06:23 UTC, and on demand, because packages are often reported malicious only days after release. GitHub sends failure notifications to the user who created the workflow or last changed its schedule. In a public repository GitHub disables the schedule after 60 days without repository activity; re-enable it on the workflow's page.

Press F5 in VS Code to launch an Extension Development Host, then open samples/conflicted.ts and run jw-differ: Open Three-Way Merge View.

The .vscode/ path in this checkout is a device node, not a directory, so no launch.json could be written. If F5 offers no "Run Extension" configuration, add one with type: extensionHost and args: ["--extensionDevelopmentPath=${workspaceFolder}"].

Layout

Path Role
src/core/conflictParser.ts Detects git conflict markers in a document
src/core/lineDiff.ts Line diff → hunks + base↔side position maps
src/core/wordDiff.ts Intra-line changed character ranges
src/core/threeWayAligner.ts Aligns the three sides into one row grid, classifies blocks
src/core/mergeResolver.ts Collapses a conflict under a chosen resolution
src/git/gitMergeSources.ts Reads the three versions from the index
src/model/hunkSplitter.ts Divides a conflict into separately decidable pieces
src/model/hunkSelection.ts Which side of which piece is pending inclusion
src/model/resolutionView.ts Row model, conflict summaries, gutter controls
src/model/resolutionController.ts Host-independent load / resolve / edit / apply
src/model/mergeDocument.ts Port onto the host's editable document
src/render/renderer.ts MergeRenderer seam a TUI can implement
src/render/html/rowMarkup.ts Rows, word spans, gutter arrows/checkboxes, menus → HTML
src/render/html/changeHighlight.ts IntelliJ change colour per block (added/deleted/modified)
src/render/html/htmlRenderer.ts Page shell, CSP, toolbar
src/host/vscode/mergeViewPanel.ts Webview lifecycle, messages, document edits
src/model/historyTypes.ts History domain types and the HistoryRepository port
src/model/historyController.ts Selection, base, merge parents, cancellable comparisons
src/model/historyGraph.ts Branch graph lanes and edges per commit row
src/model/historyVisibility.ts Search and branch filtering of loaded commits
src/model/historyBranchFilter.ts Branch filter kept by ref name; HEAD's branch by default
src/model/historyRefNames.ts Ref namespaces (refs/heads/, …) and the ref kinds they give
src/git/historyGitCommand.ts Binary-safe, bounded, cancellable git subprocess runner
src/git/gitHistoryRepository.ts Commits, refs and pinned ref resolution
src/git/historyComparisonResolver.ts Replay order, Automatic base, merge parents
src/git/gitSelectionReplay.ts Isolated replay of selected commits in a private repository
src/git/gitComparisonFiles.ts Net changed files and immutable file content
src/git/gitComparisonRepository.ts Git adapter implementing HistoryRepository, snapshot leases
src/render/html/historyRenderer.ts History panel HTML: toolbar, graph, table, files, details
src/host/vscode/historyViewProvider.ts Panel lifecycle, repositories, messages, publishing
src/host/vscode/historyDiffProvider.ts Read-only jw-differ-history: documents and vscode.diff
src/host/vscode/historyMessages.ts Validation of every message from the history webview
src/model/twoWayDiff.ts Line blocks and word spans for the two-way diff
src/render/html/twoWayDiffRenderer.ts IntelliJ-style two-pane diff HTML with token colours
src/highlight/ TextMate tokenizing and theme resolution (no VS Code import)
src/host/vscode/syntaxHighlighting.ts Finds grammars and the active theme among installed extensions
src/host/vscode/twoWayDiffPanel.ts The reusable diff tab and its native-diff fallback
media/ Webview stylesheet and client script

The core/, model/ and render/ layers have no vscode import and are unit-tested on their own; src/test/layering.test.ts enforces it.

  • Contact us
  • Jobs
  • Privacy
  • Manage cookies
  • Terms of use
  • Trademarks
  • Your Privacy Choices
  • Consumer Health Privacy
© 2026 Microsoft