VS Code — the Marketplace · Eclipse ADT — the update site
For VS Code, the recommended companion is
ABAP by Lars Hvam
(larshp.vscode-abap).
VERTEX: Get Started opens the Welcome walkthrough from the Command Palette.
VERTEX is a set of plugins for VS Code and Eclipse ADT: an AI assistant with MCP, an enhanced ABAP editor, an AI-driven ADT debugger, and explorers for code, versions and data. Each window reads over the developer's existing ADT connection and renders as HTML.
The ABAP side is this repository's src/. It is optional: in VS Code everything works over ADT
alone, and src/ is needed only to save a transport's review to SAP; without it, reviews are saved
to files. The Eclipse plugin does the same. The last column below says what needs it.
In VS Code, the built-in VERTEX Assistant can use Codex, Claude Code, a signed-in
GitHub Copilot model or API keys for Anthropic, OpenAI, Mistral, Gemini, Groq,
Cerebras, OpenRouter and NVIDIA. Provider model lists can be collapsed independently.
Each list has a Clear all / Select all control for its model checkboxes.
The VS Code chat can explain an active local .abap file using its current editor text, even without a SAP connection.
Local ABAP programs and classes support VERTEX Outline, definition navigation, UML, metrics, Logic and Calls diagrams, and forward/backward usage analysis. VERTEX bundles the abaplint transpiler and runtime. Open Visual Debug on a local file shows Run with ABAP Transpiler, with radio-button selection before launch; project configuration is generated automatically when absent. See local execution setup. SAP execution and version history still require a system.
| Tool | Grew out of | What it does | VS Code | Eclipse | ABAP backend |
|---|---|---|---|---|---|
| Enhanced Code Editor | — | Hover with a data element's domain resolved, Go to (F12), Outline, Save & Activate and block-by-block Review & Activate, ABAP Unit into the Test Explorer (Ctrl+Shift+F10), ATC into Problems (Ctrl+Shift+F2), where-used (Shift+F12), SAP's keyword documentation (F1) | ✓ | — | not needed |
| AI-driven ADT debugger | Smart Debugger | Breakpoints with conditions SAP evaluates and watchpoint logs, the run started in WebGUI, the stops, a short dump reported instead of silence, a verdict naming the line and the values; the VERTEX chat has it built in, Claude Code and Codex reach it over MCP as vertex-debug |
✓ | — | not needed |
| Visual Debug | — | The same session on screen: source, breakpoints, stack, every variable, tables as grids, the flow chart of a recorded run and its player | ✓ | ✓ ³ | not needed |
| Value Origin | ACE | Forward Usage Analysis - how a value is computed, down from a line across calls: the static call stack, the derivation as FLOW or Formula, each as a tree or a diagram; Backward Usage Analysis - where the values of a routine go in its callers, by SAP's where-used | ✓ | ✓ | not needed |
| AI Assistant | ABAP-AI-Code | Chat over any configured SAP system: reads, explains and changes code — the change lands in the tab, reviewed block by block before activation — runs the tests and ATC on an object, and drives the debugger | ✓ | ✓ ¹ | not needed |
| Versions / Reviewer | AVE | Version history, the diff between two versions, the review of a whole transport with approve, decline and comments, and the two MCP transport tools | ✓ | ✓ ² | to save reviews in SAP |
| Code Explorer | ACE | Metrics (McCabe, Halstead, maintainability), UML, the Calls diagram of an object and the Logic diagram of one method; a method opened from Calls draws its Logic diagram in the same picture | ✓ | ✓ ² | not needed |
| Data Explorer (SelecTor) | Simple Data Explorer | Tables, views and CDS with select-options, a join built from the dictionary's foreign keys, a pivot over either | ✓ | ✓ ² | not needed |
¹ In Eclipse the assistant is run by the Codex or Claude Code CLI on your own subscription, and ADT is the editor: there is no VERTEX tab for it to write into, and the debugger is not part of it. See eclipse/README.md.
² The explorer pages are shared between both hosts. The Eclipse update site carries build 0.8.8.202610092043; the VS Code extension is 0.8.8.
³ In Eclipse, Visual Debug drives ADT's own debug session instead of a second debugger, and Run opens the object in Eclipse's embedded SAP GUI. It is in the plugin source and a local test build, not yet on the update site, and has not been checked on a live ADT session. On a live stop, Eclipse opens and positions the source editor; Visual Debug no longer opens another class tab for each step.
Grew out of names where a tool's ideas were worked out first. VERTEX does not depend on those projects: nothing from Simple Data Explorer, ACE, AVE, Smart Debugger or ABAP-AI-Code has to be installed, and none of their code is called. Code Explorer, Value Origin and Visual Debug read ADT source and analyse it with abaplint in the editor; SelecTor builds its statements and reads them through ADT's standard data preview; in VS Code the version history and its diff come from ADT's revision feed, as in Eclipse's Revision History, and the review of a transport is built from them in the window, with AVE's rules for choosing the versions and cutting blocks. Saving it to SAP goes through one resource of VERTEX's own ABAP, ZCL_VX_ADT_RES_STORE, into the ZAVE_REVIEW table AVE uses too - ADT's data preview can read a table but not write it; reviews can also be kept in files. The AVE repository itself is not needed. The Eclipse plugin reads them the same way.
Where the two hosts stand apart. The editor and the AI-driven debugger are VS Code only by design: Eclipse has ADT's own editor and debugger, and VERTEX does not replace them - Visual Debug in Eclipse puts ADT's debugger session on screen rather than running its own. Eclipse also has its own built-in assistant and standalone MCP setup. Shared Tools pages are updated in the repository, but the published update site can lag behind the source until it is rebuilt.
The two transport-review MCP tools also use standard ADT, without VERTEX's ABAP
classes: they read a saved review from ZAVE_REVIEW through data preview, or build
an unsaved review from version history. They cannot save or approve reviews.
For standalone setup, including Eclipse Copilot, see mcp/README.md.
The projects named above are where the ideas were worked out first, and they are not developed further; everything new happens here.
VERTEX registers the ABAP language itself; opening SAP code does not require
another ABAP extension.
Claude Code detection also accepts a native CLI in PATH or ~/.local/bin
when its VS Code extension is absent. Restart VS Code after installing the CLI.
LLM Providers reports a missing Claude executable before offering its models.
MCP setup offers Codex or Claude Code and copies both review and debugger
registrations together. Every Welcome step has an ⓘ Info button explaining
system import, connection testing, assistant choice or MCP capabilities.
Codex also detects a standalone native CLI, including the native executable in
a global npm installation found through PATH. Restart VS Code after installing it.
On Windows, Codex detection also checks %APPDATA%/npm.
Install the extension from the Marketplace, then give it the connection Eclipse would take from the ABAP project. There is no project here, so the systems are a list and one of them is active. They live in VS Code's settings: Ctrl+Shift+P → Preferences: Open User Settings (JSON), and the entries go into that file.
A first install opens Get started with VERTEX (VS Code's Get Started page; later Help > Get Started): import the systems, test them, choose the assistant, add the VERTEX MCP server - each step with its button. The quickest way is VERTEX: Import SAP Systems (also a link under vertex.systems in Settings). It takes each
system's host and instance from SAP Logon (for a logon group, its message server's host), the client and user from an Eclipse ADT workspace - the recent workspaces of the Eclipse installations it finds are offered, another folder can be chosen - and
looks for ADT on the usual ports - 443NN and 80NN for the instance, then 44300, 8000, 50001, 50000, 443, 80, 8443,
8080 - offering only addresses that answer. VERTEX: Test SAP Systems then logs on to each configured system and
says what is wrong, if anything; the password it asks for is kept in the OS credential store, never in settings. The import also checks where the debugger can open WebGUI (/sap/bc/gui/sap/its/webgui): on the system's url it needs nothing; served on another address that answered - say url on HTTP 8000, WebGUI on HTTPS 44300 - or behind a redirect to a host this computer resolves, it writes that as webgui; found nowhere, it says so, and webgui is set by hand.
By hand, the entries look like this; the HTTP(S) port is in SMICM > Goto > Services.
"vertex.systems": [
{ "name": "A4H", "url": "https://host:44300", "client": "001", "user": "DEVELOPER",
"allowInsecureCertificate": true },
{ "name": "EXX", "url": "http://host:8XXX", "client": "100", "user": "DEVELOPER" }
],
"vertex.active": "A4H"The url is the ICM port, not the one SAP GUI connects to. An empty vertex.active means the
first. VERTEX: Switch System picks another one from a list, and the password is asked once per
system - two systems are two users often enough.
The update site address is pasted into Help → Install New Software → Add → Location; the steps, and getting back out when a p2 install goes wrong, are in INSTALL.md. VERTEX then opens from Window → Show View → Other… → VERTEX, or right-click an object in the Project Explorer → VERTEX.
For the three explorers, pull this repository's src/ with abapGit and
activate it; nothing else has to be installed. A window that needs it and does not find it says
so, and the rest of VERTEX goes on working. The table, the join and the pivot were
carried out of Simple Data Explorer, the flow and the metrics out of ACE, and the version history,
the diff, the transport lookup and the review out of AVE — first
into src/ as ZCL_VX_*, with the SAP GUI stripped off, and since then, in VS Code, into the
window itself, read over ADT. None of the three is a prerequisite any more: they are where the
logic was written first, and they are not developed further — everything new happens on this side.
The ZAVE_REVIEW table reviews are saved in ships in src/ as well.
Building either half from this repository instead: BUILD.md.
Without a variable under the cursor, Forward Usage Analysis offers FLOW with Full scope; Formula, Expression and BSE are disabled until a variable is selected.
Both Value Origin windows expose Analysis log directly above the flow. Copy log copies the engine, source loading and parsing times, source closure, definitions, dependency edges, traversal, warnings, and Formula/Expression diagnostics. The log is accessible without enabling the technical sections.
Experimental client BSE. In a VERTEX ABAP source tab, select the same variable and run VERTEX: BSE — only ADT + linter beside VERTEX: Forward Usage Analysis. The new command loads source through standard ADT, parses it locally with bundled @abaplint/core, and opens a separate window labelled ADT + abaplint. It does not request the SAP ACE origin index. It uses open editor buffers, including unsaved edits; compare saved, activated code to give both engines the same input. Source loading follows the selected value: main files first, external dependencies and local class includes only when needed, with metadata and source cached within each analysis. Full FLOW shows the loaded source closure. Interface-qualified method names are supported. The implementation shares the existing slice algorithm and reports unsupported statements. Alias analysis, dynamic dispatch and source closure are still experimental.
VERTEX: Forward Usage Analysis (formerly Analyze Variable Value Origin), on the cursor in a VERTEX ABAP source tab, answers
where that value came from - backwards across calls, without running the program. ACE indexes
and the customer sources they reference (Z*, Y*, /namespace/) are read from the same
system; standard ABAP objects stay analysis boundaries. It needs ZCL_VX_ADT_RES_FLOW in SAP
and active source. With no variable under the cursor it draws the flow forward from that line - the routine from there on and every customer routine it calls - without a slice of a value.
Value Origin takes a Type: FLOW or Formula. FLOW is what the program does — its
statements grouped by class and method, nested by blocks and their branches, with a node on each
call edge naming what that call passes (lv_scenario → IV_SCENARIO); it narrows from Full to
BSE, which is what the analysis found and the path that led to it. Formula is how the value was
computed: a = b + c at the top and the definitions of b and c as its two branches. The
Depth slider decides how far the tree opens — along the call stack in FLOW, along the
derivation in Formula — and one button beside it, offering Collapse all and then Expand all, says whether the levels shown are open, whatever the depth. Tree and
Diagram stay the two views of whichever Type is chosen. Expression (0.8.0) is a third Type: the derivation written out as one formula by substitution - a share added to the value before it becomes value × (1 + share) - with each table value a link to the statement that reads it, and, where the order of steps is configured data (a pipeline), the order of the loaded scenario.
Branches and polymorphic targets are alternatives, database-dependent loop order is a boundary. Breakpoints in the editor stop the flow where a run would stop: VERTEX names the breakpoint reached and asks whether to stop the analysis there, continue to the next breakpoint or ignore the breakpoints. VERTEX: Backward Usage Analysis goes the other way: from the routine at the cursor up into the code that calls it - a where-used that follows the value. SAP's where-used finds the calls in the saved sources; in each caller the value is followed on from the call - what it is assigned to, tested in, passed to, written with - and, where it leaves the caller through a parameter of the caller's own, up again. A value passed in is followed to where each caller took it from. With a variable under the cursor that variable is followed (a local through the parameters and attributes it reaches); with none, every parameter of the routine and every attribute it uses; with neither, the calls themselves, as SAP's where-used gives them. Standard SAP code is not followed and is named. Breakpoints stop the walk as in Forward Usage Analysis, a level of callers at a time. The tab must be saved: where-used searches the saved source.
Run Select. VERTEX: Run Select (editor context menu of a VERTEX ABAP tab): the SELECT at the cursor runs through ADT's data preview, read only, as Eclipse's SQL console runs a query, and the rows open beside the code. What only the running program would supply is left out: INTO and FOR ALL ENTRIES go, UP TO n ROWS is the row limit (otherwise 100; SELECT SINGLE reads one), and a WHERE condition that reads a program value - a variable, a parameter, a select-option - is dropped, an OR holding one dropped whole. What was dropped is listed above the rows. A program value under NOT or outside WHERE, or a dynamic table, list or condition, refuses the SELECT and says why. The statement is parsed with abaplint, saved or not. A SELECT on one table whose WHERE select-options can say opens in SelecTor instead, its conditions filled in as selection lines and each program value as an empty line to fill in; any other SELECT runs in the plain window, which says why it did not open in SelecTor. A SELECT with INNER or LEFT OUTER joins opens in SelecTor's Join, its tables in order, their ON conditions and the SELECT list carried over, when SelecTor's join takes them - it joins only the tables the dictionary offers; the selection starts folded. In a table the selection panel is a list of fields, as SAP GUI's selection screen is, each with a Shown checkbox. From Run Select only the SELECT's fields are read at first; Show hidden reads every field of the table and leaves the ones the SELECT did not ask for unticked, still there to select on.
This is a static dependency slice, not a solved runtime trace.
Idea for use: ABAP Unit in CI. Calculation classes and tests that work with the transpiler can run on a GitHub Actions Node.js runner after each push, without starting SAP. A CI repository installs its own npm dependencies and runs abap_transpile followed by node output/index.mjs; open-abap-core uses this pipeline. Tests needing SAP APIs or database behavior require substitutes or a SAP-backed test job. GitHub Actions billing depends on the repository and account plan.
In VS Code, choose Analyze Local ABAP Package on a folder in Explorer to see UML and aggregate metrics for its .abap files, including subfolders.
Click a method in UML to open its source in VS Code or Eclipse; this also works for local ABAP files in VS Code.
In VS Code, UML method links open code beside the diagram and keep focus on UML.
Metrics method links use the same side-by-side opening in VS Code, including package tables.
UML includes methods implemented through interfaces as well as methods declared directly by a class.
An abapGit folder tree may contain subpackages; VERTEX combines them for this view. Source lookup prefers the opened file's folder and reports duplicate names in a selected tree.
The same command is available from the VS Code Command Palette and opens a folder picker.
The main VERTEX Tools type list also has Local Folder, which opens the picker and shows UML or Metrics in the same window.
UML and Metrics show the current analysis stage, object count and elapsed time. Switching between them for a local folder reuses parsed source until a file changes.
UML and Metrics show the current analysis stage, object count and elapsed time. Switching between them for a local folder reuses parsed source until a file changes.
Package Metrics has Expand all / Collapse all above Objects to open or close every object's method table.
FLOW and Value Origin diagrams support graphs with more than 500 edges in both hosts.
Eclipse Tools selects the active ADT class or program when opened from its editor.
Each API provider can have several named keys, with one selected manually.
For Mistral and other compatible APIs, the VS Code chat shows the token usage returned by the provider, summed across tool calls.
With vertex.ai.logPath set, the VS Code assistant writes an Anthropic-compatible JSONL log for any provider. Each direct API or Copilot model call has its own record; CLI subscriptions are recorded per VERTEX invocation. Choose the folder in LLM Providers or Settings. Raw HTTP request bodies are not stored.
The 📜 button on the VERTEX panel opens a session report for these logs, with date, provider, model and prompt filters and token totals. It shows only question, answer and tool content enabled in log settings.
Eclipse's built-in
Assistant uses Codex or Claude Code; Copilot Chat in Eclipse connects separately
through MCP.
- VERTEX Tools — pick an object type and a name; the functions offered depend on the type (Data, UML, Metrics, Calls and Logic diagrams, Diff, Versions). There is no View source: the source is the editor tab, and its parts are VS Code's Outline. Visual Debug is the panel beside the editor. Clicking a method in the Calls diagram opens its Logic diagram inside the same canvas, joined to the block it came from; the magnifier icon magnifies the diagram under the pointer, the same lens in every diagram.
- The ABAP editor — hover, Go to, outline, Save & Activate and the block-by-block Review & Activate; Ctrl+Shift+F10 runs ABAP Unit into the Test Explorer, Ctrl+Shift+F2 runs ATC into the Problems view, Shift+F12 shows where-used, F1 opens the keyword documentation.
- VERTEX chat — Claude or ChatGPT through a subscription or an Anthropic API key, over every
system in
vertex.systems; it reads, explains and changes code, and nothing reaches SAP until you save. Run the tests for ZCL_FOO and run ATC on ZCL_FOO are answered by running them: the result in the chat, the same run in the Test Explorer and the Problems view. - The debugger for an assistant — Z_CALC computes the wrong discount, find out why: the assistant sets conditional breakpoints, runs the program in WebGUI and ends with the line and the values that prove it. Visual Debug shows the same session on screen, with a flow chart of the calls and a player for the recorded run.
- Assistant in SelecTor and Versions — a sentence instead of the clicks: SFLIGHT for carrier AA, joined with SCARR.
Everything, with its settings and commands: vscode/README.md.
- VERTEX Tools — the same pages as in VS Code, opened from Window → Show View → VERTEX or the context menu of an object, on that object's own ADT project.
- VERTEX Assistant — the chat over the ABAP project's system, and the Assistant panels in SelecTor and Versions, run by Codex or Claude Code.
- VERTEX: Activate — ADT's activation, optionally after the block review.
Setup of the assistant: eclipse/README.md.
The extension serves two MCP servers, and an assistant can take either.
The transport review. GitHub Copilot, Claude Code and Codex get two read-only tools:
sap_transport_changes lists what a request changed, and sap_transport_diff gives the diff in
review blocks with the verdicts already given. The VS Code extension serves them itself; without VS
Code, mcp/ serves them over stdio. Setup:
in VS Code ·
Copilot in Eclipse · without VS Code. The tested clients are
Copilot in VS Code, Claude Code and Codex; others are not supported yet.
The debugger. Claude Code and Codex get the whole ADT debugger as a second MCP server of the
extension, /debug, registered as vertex-debug: debug_set_breakpoint (with a condition SAP
evaluates, or mode log for a watchpoint), debug_run, debug_wait, debug_read, debug_step,
debug_status, debug_log, debug_clear_breakpoints and debug_stop. Nothing there changes a
variable or the code. It is the same session the VERTEX chat and Visual Debug drive, so a step
made in one is seen by the others. It runs on the active system, needs a VS Code window with
VERTEX open — the run is started in WebGUI and the listener has to outlive a single call — and
for that reason the standalone server in mcp/ does not have it. Setup and the
tools one by one: Debug with an assistant.
SelecTor offers Technical names / Text for Selection field labels and table headers, retaining the choice between loads.
| Word | Comes from | What it does | In VERTEX | Status |
|---|---|---|---|---|
| Data | Simple Data Explorer | Tables, views and CDS with select-options, joins, pivot | SelecTor | A table with filters, a join built from the dictionary's own foreign keys, and a pivot over either |
| Version | AVE | History, diff, blame, code review of a whole transport | Versions | A transport — by its number, or picked from the open or released requests of a user, yours by default — a package or one object; its parts, their versions, the diff between two of them, and the review of a request — built, saved, approved, declined and commented on block by block. No blame |
| Code | ACE | Metrics, call maps, backward slicing, skeletons | Metrics | Three modes: the flow of a program, the branch scheme of one method, and McCabe, Halstead and the maintainability index per unit. A method opened from the Calls diagram draws its branch scheme in the same picture |
Status: early. All three answer, and each is a fraction of what it was cut from.
Building a review is here too, not only reading one. In VS Code a request with no saved review is
built from ADT when it is opened - every part it changed, the pair of versions chosen by AVE's rule,
diffed and cut into blocks by AVE's walk - with the status line saying which part is being read;
Save keeps it, in ZAVE_REVIEW or in files as vertex.review.storage says, and approving,
declining and commenting then change it the way AVE does. AVE's SAP GUI writes the same
ZAVE_REVIEW, so a review saved either way is read by both. The Eclipse plugin builds and saves a
review the same way; where it keeps reviews is set in Window → Preferences → VERTEX Code Review.
The diff is a shortest edit script over whole lines with nothing on top. In Eclipse it is Eclipse's
own Text Compare (RangeDifferencer); in VS Code it is VERTEX's own line differ, Myers' algorithm,
written from the published algorithm because Eclipse's comparer is under the EPL and VERTEX is MIT.
The division of labour is the same for all three: ABAP computes and returns JSON, the page
renders it, and the view in between is transport. Nothing about a service lives in the host, so
every page runs under the VS Code extension in vscode/ as well — the same files, from the same
folder. And since SAP GUI 8.0 draws on the same WebView2 engine as both editors, one day inside
SAP GUI too.
Every service registers under the one /vertex/ prefix, because that prefix is where the ADT
node is claimed and not the identity of the service: a second one would mean a second BAdI
implementation and a second filter to get wrong. The hub lives in this repository, under
src/, together with everything the windows read except the review — so there is one thing
to install and one registration to make. The prefix used to be /zsde/, from the repository
the hub was first built in; that hub is gone, and a system still carrying it answers each prefix
under its own filter.
The page receives finished JSON and knows nothing about SAP. That is what makes the second
host possible: vscode/extension.js reads the very same files and answers them over plain
HTTPS, and the markup, grids and filters are not written twice.
Reading and writing an ADT resource from Java, the WebView2 callback deadlock, and how to read signatures off the bundles when web search has nothing: ADT_TECH.md.
What each folder and file of the repository is for: BUILD.md.
The experimental client BSE parser uses abaplint by Lars Hvam and contributors (MIT). @abaplint/core is bundled in the VSIX; no separate installation or lint extension is required. Its licence is included in licenses/abaplint-MIT.txt.
The VS Code extension talks to SAP ADT through abap-adt-api by Marcello Urbani (MIT): reading and writing source, activation, the debugger, ABAP Unit, ATC, where-used, keyword documentation. It travels inside the VSIX with its licence, as do the other npm packages it depends on (MIT, Apache-2.0, BSD-3-Clause), each in its own folder. The Eclipse plugin does not use it: it works through the platform and ADT only.
What is still missing, and what has to come out before it ships: Next.md.
For feature instructions, see VS Code documentation and Eclipse documentation. For changes between releases, see history.md.