Repository navigation
Releases
v0.27.0
Added
- The BC Atlas view as an MCP App. In a chat client that renders MCP
Apps (Claude, ChatGPT, VS Code, Goose, ...) the MCP toolbc_atlas_app
shows the interactive view inside the conversation: the graph with every
lens, the findings, the stories, the builders for flows and processes,
and the Architecture menu. It is the page the VS Code extension shows,
answered by the same service, so it also changes flows, processes, the
simulation, and the architecture. What the view exports is saved to
.bca/exports/. From now on the view is released for both hosts
together; a test keeps every request of the page answered by both.
Fixed
- A proposal for a large app no longer falls into one component. Groups
smaller than 1% of the app joined a neighbour, so in an app of 1,500
objects or more a real module of a dozen objects counted as dust; with a
finergranularityevery group was that small, all of them joined each
other, and one component was left. The limit is now at most 10 objects,
and a group that took others in and is no longer small stays. Large apps
get more and smaller components from the default settings too.
v0.26.0
Added
- The architecture in the view. A new Architecture menu shows how
well the architecture meets the goals of the template in use (each goal
with its score and weight), lists the components with why each is what it
is, takes a template into use, saves your weights as a template of your
own, and compares the current with the target architecture: choose the two
states and the weights, read the scores, the mapping of the components,
the proposals that competed, and the steps with commands to copy, and make
the target the architecture of the project. The panel of a component says
Why this component, the panel of an object Why in …. An exported
file carries the comparison it was exported with.
Changed
- Components named after the same word are told apart by the namespace or
folder most of each is in (Posting (Sales)) before a number is used.
v0.25.0
Added
- Why a component is what it is. A proposal remembers for every object
the step that placed it (its coupling, the shared core, a small group that
joined, a neighbour by namespace, folder, or ID, a permission set that
follows what it grants, kept, ...) with the numbers that step looked at,
and for every component what it is named after, what its objects agree on,
and every threshold that applied.bca architecture --explaintakes an
object or a component, the report has Why these components, and the
MCP toolbc_atlas_architecture_explainanswers both for an agent. - Current and target architecture.
bca architecture compareputs the
architecture as it is (the namespaces, folders, and apps of the source, or
what.bca.jsonconfigures) next to the one it should be (configured, the
proposal, or the best of several proposals): both scored from 0 to 100
with the same weighted goals, how the components of one become those of
the other, the objects that have to move with the command for each, and
the steps in order.--writemakes the target the architecture of the
project. - Goals with weights, and templates. Twelve goals say what is preferred
(cohesion, modularity, layering, no cycles, data ownership, extractable,
stable dependencies, size, following namespaces, folders, and apps, few
moves);--weight <goal>=<n>andarchitecture.goalsweigh them. A
template bundles the weights with the settings of the proposal: six
presets (balanced,follow-structure,by-coupling,layered,
modular-monolith,small-steps) and your own, which can extend another
and live in.bca.jsonor in a file several repositories share.
bca architecture templateslists, uses, saves (--save <name>: the
settings as they are), and removes them. - For agents: the MCP tools
bc_atlas_architecture_compare,
bc_atlas_architecture_templates, andbc_atlas_architecture_adopt, and
template,weights, andsizeonbc_atlas_architecture, which now
also returns the score of the architecture for every goal.
Changed
- Names of components no longer clash. Names are compared without case
everywhere. Two components that would get one name are told apart by what
they are: the level above first (Sales Setup,Purchase Setup), then
the app, and a number only last.architecture.proposal.namingrenames
components (rename), chooses what tells them apart (qualify), and
keeps a component from sharing its name with an app, a module, or a
namespace it only partly covers (avoid).
v0.24.0
Added
-
Triggers of your own. A flow no longer runs on one of five triggers
only: any other name underautomation.triggersis a trigger of your own,
started by pipeline events (push,pull-request,tag,release,
manual, withbranches,paths, andtags), by acron, by a Git
hook(post-merge,post-commit, ...), or by its name only
(bca run --trigger <name>from a script of yours).
bca flow define --trigger/--untriggerdefines them, the builder has
New trigger… and a form on every trigger node,bca setupkeeps them
and installs those that are a hook, andbca flow exportwrites a
pipeline that starts on them, finds out which trigger it was, and delivers
the way that trigger says. -
Documentation profiles. What the layered documentation writes, and
how, is set underlayersin.bca.json:pages(which kinds of page,
which lenses and stories),scope(apps, components, namespaces, object
types, names to leave out),sections(which sections of each kind of
page, in which order),titlesandlanguage(de: the headings,
tables, and fixed texts in German),names(file and folder names by
pattern; every link follows), andtemplates(a Markdown file per kind
of page with placeholders for the title, the summary, the picture, and
each section). Named
profileswrite several documentations from one source, each to a folder
of its own:bca layers --profile <name>, theprofileargument of
bc_atlas_layers, and the optionprofileof alayersstep in a flow.
Without any of these keys the pages are byte for byte what they were. -
Undo in the builder (the button, or Ctrl+Z), for flows and for
processes: the last change is taken back as one checked operation. -
bca flow export --to azure-devopswrites a flow as a pipeline of
its own for Azure Pipelines (azure-pipelines.bc-atlas-<flow>.yml); the
builder has For Azure Pipelines next to For GitHub Actions. -
How sure the telemetry is. Mining and the run say how the events
found their step: only one step can have them, by who did them, or only
by where the case was. When a third or more are of the last kind, the
findingprocess-telemetry-uncertainsays that the times are an
estimate. The guide has a sketch in AL for sending one event per step.
Changed
-
The canvas of the flow builder is React Flow (
@xyflow/react, MIT,
vendored: nothing is loaded from the internet) instead of a canvas of our
own, with BC Atlas' nodes for triggers, flows, and artifacts on it. New
with it: a minimap, zoom and fit controls, touch, Shift-drag to select and
remove several nodes at once, wires that show while they are pulled
whether they may end where they are, and the buttons of a node and the
choice on a wire as the library's own toolbars on what is selected. The flows,.bca.json, andbca run
are as before. An exported view (bca export --view app) is about 410 KB
larger for it. -
bca run --triggerand the MCP tools take any trigger name, not only the
five built-in ones. -
A change to the flows or the processes no longer reads the project
again. In VS Code the graph is read again on the analysis that is
there, so a wire or a step is as fast on a large project as on a small
one. A change to anything else in.bca.jsonreads the project as
before. -
A custom dimension and an event id of the app are taken with or without
the prefix Business Central may give them (al). -
An exported view refuses a change the project would refuse (a place that
is saved twice, a file of the wrong kind, a step that comes after a step
that is not there) instead of keeping it for later.
v0.23.0
Added
-
Processes: how the company works with the app. A process is a model
in lanes, as in BPMN ("processes"in.bca.json): every step in the
lane of the role that does it, with the process test or recording that
shows it works, and what it comes after; a wire with a name is one way
of several.- Telemetry gives the time. With exported telemetry of Business
Central (processTelemetry.path,--telemetry; orprocessTelemetry.appIdand
BCA_TELEMETRY_API_KEYto ask Application Insights), mining and the
run have the cases, how long a case takes, the ways really taken
(the variants), per step how often and how long, and per way how
long the work waits. Findings from it: where the work waits longest,
rework, a step that is far slower than the others, a way that is
gone and not in the model, a step that is never seen. - Loops: a wire may lead back to an earlier step, in the builder,
in.bca.json, and from BPMN. - Process mining:
bca process --minediscovers the processes as
they are from the process tests and the recordings of Business
Central: the order, the role that performs each step, the handovers,
and the events of each step (clicks, pages opened, code run, reads,
writes).bca process define --adopttakes one as a model. - The run is the test and the demonstration:
bca process run
walks each process with the people of the simulation and says who
performs a step, what stops a lane (the missing permissions), and
where the work changes hands. It exits with 1 when a process stops. - What to improve: a step that is blocked, done by another role,
unstaffed, or unproven; a lane that is no role; work that goes back
and forth; steps the tests have and the model has not; an order the
app does not allow. Each with what to do. - The process builder (Flow → Open the process builder): lanes
to build on. Take a mined process, drag process tests and recordings
into the lanes, drag a step to another lane, pull wires between
steps, name the ways, and Play the process on the graph. - The lens Process models, a story per process, and the findings on
its steps. - BPMN 2.0 out (
bca process export, BPMN in the builder) and
in (bca process define --import). - The MCP tools
bc_atlas_processandbc_atlas_process_define. - Guide.
- Telemetry gives the time. With exported telemetry of Business
-
Flows: your own workflows. A flow says what to make from the source,
when, and where to save it: an id, the triggers it runs on, and steps,
each one artifact with its place and options ("flows"in.bca.json).
The artifacts are everything BC Atlas makes:layers,report,
handbook,catalog,docs,simulate,check,view(any lens or
story as a picture, a page, or data),diagram,app,
knowledge-graph, and the tasks of plugins. The same artifact can be
made more than once, with other options, in other places.- The Flow menu of the view is the builder: a flow with its
triggers, its steps with a form for the options of each artifact, the
order of the steps, the sync mode of each trigger, and Run now. In
VS Code a change is written to.bca.json; an exported view saves the
changes asflow-changes.json. - The steps of a flow are a graph. A step can come after others
("id"and"after", or--idand--after), if each of them
passed (the default), failed, or always.bca runruns every step
after those it waits for and skips one whose condition does not hold:
"write the pages only when the health check passed", "save the report
when it failed". Steps that wait in a circle are not valid. A flow
written as a list is unchanged: every step starts with the flow. - The flow builder (Open the builder in the Flow menu) opens on a
canvas to place and wire freely: every trigger, flow, and step is
a node with ports. Drag nodes from the palette onto the canvas and pull
wires: a trigger into a flow, a flow into the steps it starts with, a
step into those that come after it. Wires branch and join, a click on
a wire says when it holds (passed, fails, in any case), and a wire
that would close a circle is refused. Select a node or a wire and
remove it, double-click a node for its form, pan and zoom. A node no
wire leads to stays on the canvas, in no flow; steps that leave a flow
together keep their wires and come back together. Where
the nodes are is kept in.bca/flow-canvas.json. - One rule for a step that is removed, in a flow and in a process,
wherever it is removed (the canvas, a form,--unstep, an agent):
the way closes around it, and what came after it comes after what it
came after, on the condition it had. A step that came after nothing
else starts the flow, and BC Atlas names it. Taking a wire away
leaves a step in no flow, kept on the canvas with what ran only
through it. The earlier lanes board of the builder is gone: its
place is taken by the processes. - The lens Flows shows them as a diagram: the trigger that starts a
flow, the artifacts it makes, and where each is saved. bca flowshows the flows and the catalog of artifacts
(--artifacts);bca flow definechanges them (--flow,
--step,--to,--set,--at,--up,--down,--unstep,
--remove,--deliver,--from). A flow that is not valid is never
written.bca runruns the flows of a trigger after its tasks and delivers
what they save with the sync mode of the trigger;--flow <id>runs
one by name. The pipelinebca setupwrites knows their places.bca flow export --flow <id>writes a flow as a workflow of its
own for GitHub Actions (.github/workflows/bc-atlas-<flow>.yml): it
runs on the events of the flow's triggers (pull requests and pushes,
the schedule, by hand) and delivers what the flow saves as the sync
mode of the trigger says (verify, artifact, pull request, commit). The
Flow menu has the same as Export → For GitHub Actions, and agents
the MCP toolbc_atlas_flow_export.- The MCP tool
bc_atlas_flow_define, andflowsonbc_atlas_run. - Guide.
- The Flow menu of the view is the builder: a flow with its
v0.22.0
Added
-
The overview: how it works. The view opens on a new lens. It shows
how the app works in columns with their titles, from left to right:
people, processes, screens, logic, data. Lines are quiet (no arrows, no
colors; a line runs from a column on the left to one on the right), and
a click lights the way of what is selected: a process test with who
performs it and everything it touches, an object with what uses it,
what it uses, and the process tests that touch it. Permission sets,
enums, and test codeunits are not part of it. Above 48 objects a box is
an area (a component, a namespace, or an app) with the number of objects
it holds, and a double click goes into it.bca view --lens overview
writes it as text in the order of the columns, or as a picture. -
How it is connected, what to change, and how.
bca layersnow
answers these on two new pages.architecture.mdshows the apps of a
repository and what each uses of the others (declared, undeclared, not
found), the components in their layers with what depends on what, and
the tables written from outside their component, each part with a
picture.changes.mdlists every change to the architecture the
analysis finds, the most important first: decide on an architecture,
declare a dependency between apps, break a cycle, resolve a dependency
the wrong way, let a component own its table, narrow the public surface,
extract a component as an app. Each change says why, gives the steps and
the effort, and names the command when BC Atlas can do it. The first
page starts with where to read, and the page of an app, a component, a
namespace, and an object names the changes about it. The command says
where to start and what there is to change. -
The list of changes is part of the atlas (
changesin the
atlas.jsonof the documentation): the story What to change, and
how of the view walks through it on the graph, and
bca view --story architectureprints it. It replaces the story "Dependencies the wrong way" and is
there also when nothing is to change. -
MCP tool
bc_atlas_layers: writes or checks the documentation and
returns the changes. -
bcawithout a command starts with where to begin. -
Component nodes carry
cohesion(how much of the coupling stays inside,
in percent) andcycle; the summary of the architecture carries
inside.
Changed
- Less noise in the view. The lens menu lists the lenses under what
they answer (how it works, structure, parts, people and rules, quality),
one line each. A lens opens in the form it reads best in: the overview,
processes, people, requirements, the simulation, runs, components, and
apps as a diagram, the rest in a plane;--formand the address of the
view still say otherwise. The legend of the overview starts folded. - The story of the system starts with how it works.
bca viewwithout--lensand with a picture or--insideshows the
overview, no longer the System lens;--lens systemgives that.- Object nodes of test codeunits carry
test: true.
v0.21.0
Added
bca bundle: everything as one artifact. One folder and one ZIP file
with a manifest: validation (the health check), the simulation, a snapshot
of every process test, the layered documentation with the view, narrative
pages when a model is set up, and the test results (--test-results,
JUnit or xUnit XML) and build outputs (--include) it is given.
bundle.jsonnames the commit, every step with its result, and every file
with its hash. Exit code 1 when a step failed; the bundle is written all
the same. MCP toolbc_atlas_bundle. See The bundle.- Simulate on recordings. With
simulation.recordings(or
--recordings) the agents perform the recordings of Business Central as
well. What really ran says what it takes: Execute on the pages,
codeunits, and reports on the call stacks, and the table right of every
read and write. A recording with the title of a process test adds what
really ran to that test; any other recording is a process of its own, so
a process can be simulated before anyone wrote a UI test for it. - Snapshots from the source.
bca simulate --snapshots <folder>(or
simulation.snapshotDir) writes one fact snapshot per process test in the
schema of the recordings: its steps as phases, what each step needs as
technical steps, and who performs it. - A run of the simulation, step by step. A run shows how the result
came about: one person performs the assigned process tests, and each step
shows where the person is. The picture is built by it: it starts with the
person, every step adds the process test and the objects it needs, and
where the person is stopped the step says which permission is missing and
what to add. In the view under Simulate › Run, step by step; in the
terminal and for agents as the storiesrun:<person>ofbca viewand
bc_atlas_view; inbca layersandbca bundleas one page per run
with its picture. The new lens Run is the canvas of all runs. - Simulate and build in one place. The Simulate menu of the view builds
the bundle (in VS Code), and the bundle has the step Runs, step by
step. - Simulate in the view says what stops it. The menu lists the findings
of the simulation at the top, each one click from the person or the
process test it is about, and Start from the process tests writes the
company the tests describe as the start of your own.
v0.20.0
Added
-
bca layers: the layered documentation, in sync with the source. The
system explained from the whole down to each procedure: one page per app,
component, namespace, and object, each with a picture and a sentence that
says what it is; the procedures, triggers, and events of an object with
what each reads, writes, and calls; and lenses, stories, and findings
across them. Every page links one layer up and one layer down. See
Layered documentation.- In sync. The same source gives the same files, byte for byte, so a
run writes only what changed and removes what it no longer writes.
--checkwrites nothing and fails when the pages are behind the
source.layersis a task ofbca run, withlayers.outputDir,
pictures,history, andviewin.bca.json. - The source as it was.
--at <commit, tag, or release>records the
same pages for that state belowhistory/, read from a temporary
checkout;--releasesrecords every release not recorded yet.
history/README.mdlists the states and what changed from each to the
next: objects added, removed, and changed, relations, and findings new
and fixed. A recorded state also holdsview.html, the BC Atlas view
of it to open in a browser.
- In sync. The same source gives the same files, byte for byte, so a
-
BC Atlas AI, an optional built-in plugin: narrative documentation
written by a language model, from facts. BC Atlas itself still calls no
model. The pluginaiis the one place one is called, through one
OpenAI-compatible endpoint, so a gateway routes to any model of any
provider. See BC Atlas AI.bca ai contextprints the grounding of a subject (the system, or a
process of the battle test): steps with what each needs, who performs
or is blocked, requirements, what the recording of Business Central
shows, findings with fixes. No source code. It calls no model.bca ai writewrites one page per subject next to its grounding, and
again only when the grounding, the model, or the language changed, so a
run without changes calls no model.--dry-runsays what would be
written.- Settings:
ai.endpoint,ai.model,ai.outputDir,ai.languagein
.bca.json, orBCA_AI_ENDPOINTandBCA_AI_MODEL. The key comes
fromBCA_AI_API_KEYonly, never from a file. - The
aitask ofbca run, and the MCP toolsbc_atlas_ai_contextand
bc_atlas_ai_write. - Plugins get
context.services.atlas(): the whole graph.
-
Define the simulation, from the view, the terminal, and an agent. The
company of the battle test is changed by operations instead of by hand:
add or change an agent, a role, a task group, or a requirement, remove
one, ground a process test on a recording. Each change runs the simulation
at once, and what is not valid never reaches.bca.json. See
Define the simulation.- Simulate, a menu next to Story in the toolbar of the view: the
company, its agents and roles, and a form for each; Define… on the
card of a person, a role, or a requirement. In VS Code a change is
written and the graph shows the new result; an exported file saves the
changes assimulation-changes.json. bca simulate define:--agent,--role,--task-group,
--requirementwith their fields,--remove,--ground,--init,
--from,--dry-run. Without options it shows the simulation.bc_atlas_simulation_define, an MCP tool that takes the operations
and returns the definition and the result of the run.
- Simulate, a menu next to Story in the toolbar of the view: the
-
The Simulation canvas. A new lens shows the company as one picture:
people, their roles, the process tests each role does or must not do, who
is blocked, the requirements the tests prove, and the recordings they
stand on. Roles are nodes of the graph. -
Grounding. A process test stands on the recording of the same process
in Business Central (by title, orsimulation.grounding). Where the test
and the recording go through different objects is the finding
grounding-differs; a named recording that is not there is
grounding-missing.
Fixed
- The 3D form is in space. It looked like the 2D graph seen from the
side. Now the eye stands closer, so what is in front is clearly larger;
nodes are balls with light on them; relations behind are fainter and
those in front stronger; the graph stands over a floor of rings and
spokes and turns slowly until you turn it, point at it, or select a
node. Pictures ofbca view --form 3dshow the same.
v0.19.0
Changed
- The app is one view: a toolbar and the graph. The pages, the list of
contents, and the tabs are gone, in VS Code and in the filebca export
writes. The AL source is the only fact; everything BC Atlas reads from it
is one graph, and the toolbar decides which part of it shows, in which
form, and what stands out. See The BC Atlas view.- One graph. Apps, components, namespaces, objects, the rules of the
health check, process tests, the people who perform them, and
requirements are nodes; what they do with each other are relations, one
per kind (reads, writes, calls, permits, depends on, the wrong way,
touches, performs, blocked, ...). A node keeps its identity everywhere:
select an object, switch the lens, and it is still selected. - Lenses show a part of it: System, Components, Apps, Modules, Data,
Calls, Events, Contracts, Pages, Permissions, Visibility, Findings,
Processes, People, Requirements. A lens with nothing in it is left out. - Three forms on one canvas, for every lens: a 2D graph, a diagram
(the same nodes as boxes in layers, in the direction of their relations,
with relations routed between the boxes), and a 3D graph. Selection,
search, and what is hidden stay when the form changes. - Open an object: a double click shows it from the inside, its
procedures, triggers, and events as nodes and what each of them does
with other objects; a double click on a procedure goes to its line. - Check puts every finding on the nodes it is about: health rules, AL
compiler and analyzer findings, architecture violations, and what blocks
a person in the battle test. The card of a node lists its findings with
the fix. - Stories, generated from the source, walk through the graph step by
step, each step with a text and the nodes it is about: what the system
is, one story per process (its tests in order, every step on the objects
it touches), who can do what, what to fix, and the dependencies that
point the wrong way. Play a story to demonstrate, save it as Markdown to
document. - Everything exports: the picture as PNG or SVG, the graph as JSON,
nodes and relations as CSV, a lens and all stories as Markdown, and a
link: the whole state of the view is in its address. - In step with the source: in VS Code the graph is read again when a
file is saved and keeps its lens, form, and selection; the object of the
active editor is the selected node (bcAtlas.followEditor); Go to
source opens a node at its line; Live says what the graph is read
from and saves a proposed architecture or the baseline.
- One graph. Apps, components, namespaces, objects, the rules of the
bca view: the view without a window. Everything the toolbar does is
an option, and every export a format, so the terminal, a pipeline, and an
agent get what the app shows:--lens,--inside,--focuswith
--depth,--find,--hide,--off,--check,--storywith
--step,--stories,--color,--size,--group, and--format
text,json,md,csv,svg,png, orlink. Pictures come in
every form (--form 2d,diagram,3d), light or dark, drawn without a
browser, the same every time. Without options it lists the lenses and
stories of the project;--format jsonprints the whole graph. One
implementation draws the page and writes these files
(src/app/ui/scene.js,graph.js). The MCP toolbc_atlas_viewgives
agents the same.- Navigation without a jump. Every node leads on: a double click goes
into an app, a component, or a namespace (its objects), into an object
(its procedures), or to the lens a person, a process test, a requirement,
or a recording lives in. A trail next to the lens says where the view is
(Components › Core › CON Item), and every part of it is one click back.
See in on the card of a node lists the other lenses it is in and
changes the lens around it. A node that is in the picture before and
after a step stays where it is; between 2D, Diagram, and 3D the nodes
glide and the camera turns; the picture fits next to the card of the
selected node, not under it; the Back and Forward keys of a browser
follow every step. Keys:[]the lens before and after,Backspaceone step
up.bca view --insidetakes an app, a component, or a namespace too. - Plugins add to the graph. The new contribution
atlaslets a plugin
put nodes, relations, lenses, findings, and stories into the one graph;
they show in the view, inbca view, in the MCP toolbc_atlas_view,
and in every export, like those of BC Atlas. See
What a plugin adds to the graph.
bca view --lensaccepts the lenses of plugins. - Recordings of Business Central are in the view. The built-in plugin
syncadds the lens Recordings: the channels, every recorded process
with its state (in sync, or why it waits), and the AL objects it runs
through and changes. A recording that waits for a sync is the finding
sync-outdatedon its node, and the story "What runs in Business
Central" walks through every recording phase by phase. The purchasing
example has two recordings. - An export of a lens (JSON, CSV, Markdown) holds what shows: what the
legend hides is left out, and findings come the most severe first. - The exported file is much smaller (the example with three apps: 120 KB
instead of 940 KB; 3,150 objects with 11,000 relations: 300 KB) and opens
in half a second. - VS Code: Open a Lens… replaces Open Page…, Show This Object from the
Inside replaces Diagram of This Object, Show the Components replaces
Propose an Architecture. The side bar opens the view and has no list.
Removed
- The pages of the app: Overview, Health, Architecture, component pages,
Dependencies, Diagrams with settings, Objects, object pages, and Docs, and
with them the table form, saved views, and the visibility canvas of
circles. What they showed is in the graph: as lenses, as facts and
findings on the card of a node, and as stories. - In the app: the 3D explorer with its timeline, the handbook pages, and the
user guides. They are still written as files:bca export --view explorer --history,bca export --view handbook, andbca docs generate.
--historyno longer applies tobca export --view app. - Choosing a grouping for a proposed architecture in the app, and keeping a
component or excluding an object from shaping. Setarchitecture.proposal
in.bca.jsonor usebca architecture --propose.
v0.18.0
Added
- Plugins (plugin API 1, docs): a plugin declares in
plugin.jsonwhat it contributes — commands (bca <plugin> <command>),
tasks forbca run(placed with before/after, outputs included in verify,
stage, artifacts, and pull requests), health rules forbca check, MCP
tools, hooks (run:before,task:after,run:after,check:after), and
extension points for other plugins. Code runs only when a contribution is
used, throughactivate(context)with the project, its config section, a
log, and services (architecture model, docs renderer). Plugins come built in
(plugins/), from npm (bc-atlas-plugin-*dependencies, no configuration),
from"plugins"in.bca.json, or fromBCA_PLUGINS. bca plugins list|show|doctor|new: see what a project's plugins
contribute, check every declared contribution, and start a plugin from a
working template.- Built-in plugin
sync(formerly the separate bc-atlas-sync repository,
imported with its history intoplugins/sync): Business Central process
recordings (clicks, writes, AL call stacks as fact snapshots) synced into
documents, BC Atlas UI tests, the architecture layer, and a process index —
bca sync plan|run|status|describe, thesynctask (beforedocs), the
sync-outdatedhealth rule, thebc_atlas_sync_statusMCP tool, and the
extension pointssync.sourcesandsync.formats. Includes the BC Atlas
Sync AL extension, its tests, and the Playwright run. - Visibility view (
bca export --view visibility): what is public,
internal, or local, in three levels and three colors. Every app, object,
procedure, event, and table field is a data point with its level: public
(other apps can use it), internal (this app), local (this object). A
relation is as wide as the border it crosses. Where the uses found need
less, a dashed border says what the data point can be: a procedure nobody
calls from outside its object can be local, a codeunit no other app uses
can beAccess = Internal. One box per object by default,
--expand-proceduresfor every member inside its object,--focusfor a
part,--format jsonfor the data points and uses. Also in
bca export --view report --views ...,visibilityand in the MCP tools. - In VS Code and the offline app the visibility view opens as a canvas:
graphs in graphs. An app holds its objects, an object its members, and a
procedure the data points it uses and that use it, which open again,
without an end; local sits at the core of every circle, public at the rim.
Click a circle to go into it, search by name, show only some levels, and
switch to the diagram of boxes. See
Architecture diagrams. - Dashboard, the page where VS Code and the offline app now open: every
content in every form. Pick what to look at (a diagram view, the
components of the architecture, the objects, the apps, the health
findings) and how (2D graph, 3D graph, table, and for diagram views their
diagram), independently. A diagram view can be a 3D graph, the
architecture a table, the objects a graph. The filter and the tools are
the same for all: filter by name, type, group, and kind of relation, show
only a node and its neighbors, hide nodes, size them by a number, put them
where you want them, sort the table, save a PNG or CSV. New view from
this keeps what you see under a name in My views. See
The Dashboard. - One list instead of tabs. The pages (Overview, Health, Architecture,
Dependencies, Diagrams, Objects, Docs) are no longer tabs: one list on the
left holds everything by topic, the contents of the Dashboard next to the
page of the same topic, with a filter above it. Every page works as
before. In VS Code the panel has this list too, so the BC Atlas side bar
is a set of shortcuts and no longer the only way to a page. - Every page says what it is read from: Sources below the list (AL files
and objects, apps, symbol packages, AL compiler, settings), and for a
content of the Dashboard what that content reads. - Battle test: simulate the use in your company.
bca simulatelets
agents with the roles, permission sets, and task groups of your company
perform the process tests of the app (the AL UI tests with[SCENARIO])
step by step. For every step it follows the code behind it and checks what
the agent needs: Execute on the page and on every codeunit, page, or report
the code calls or runs, the table-data rights for what it reads and writes,
and the codeunits of event subscribers. One run is an automatic test (exit
code 1 when a role is blocked, or can do what it must not), a process test
(does each use case run end to end across roles?), and the data the
documentation is written from: who can do what, an explanation of every
permission a step needs, the permissions a role holds but no task needs,
and a fit-gap analysis of your requirements against the app (fit, gap in
permissions, nobody assigned, not proven by a process test, not in the
app). Describe the company undersimulationin.bca.json(roles,
agents,taskGroups,requirements,mustNotfor segregation of
duties) or in a file (--company); without it, every combination of
[PERMISSIONS]in the tests is a role. Text, Markdown, or JSON, in English
or German. Also a task ofbca run(simulate, report in
docs/simulation), a page of Docs in VS Code and the offline app, and
the MCP toolbc_atlas_simulate. See Battle test
and the new purchasing example (examples/purchasing-app,
report). - The model keeps which rights a permission grants only indirectly
(indirectRights:tabledata "X" = Rireads directly and inserts
indirectly).
Changed
bca setup(andbca update, which runssetup apply --from-config) keeps
the tasks it does not ask about in their triggers: plugin tasks,simulate,
handbook, anddiagramswere dropped before.- A group in a diagram is at least as wide as its name.
- Docs and Handbook are one page in VS Code and the offline app. The
list shows the system handbook first, then the user guides and test cases
from UI tests. Sources beside each page says what it is read from. The
page is there without UI tests too. Old#/handbook/...links open the
same page in Docs. - Every handbook page starts with Based on:, the parts of the AL code it
reads. The overview ends with a Sources table: AL files and objects,
apps, symbol packages with versions, the AL compiler, the architecture, and
.bca.json.
Fixed
- An object's
propertiesare its own. The properties of a group, repeater,
grid, cue group, action group, view, request page, rendering layout, field
group, ormodify(...)inside it no longer count as the object's, so the
caption of a page is the page'sCaption, not that of its last captioned
group (the same forApplicationArea,Editable,ToolTip,Visible,
andSourceTableTemporaryof a request page). An XMLport element no
longer lists the properties of its attributes. - Objects, table fields, page fields, and procedures whose header is split
by#if(#if X/table 50100 "A"/#else/table 50101 "A"/
#endif/{ ... }) are in the model. They were missing: a table declared
this way did not exist, nor did its fields. Each is there once, with the
header of the first branch (#if): ID, name, type, source expression,
access modifier, parameters, return type, and attributes. Its
conditionalSymbolsnames the condition of that branch. The body is shared,
so its properties, fields, and code count as usual. What the other branches
refer to still becomes a relation with the condition of its branch: the
interfaces of animplementslist, the record types of parameters, and a
base object that differs by branch. - A relation found in the shared body after
#endifof a procedure with a
split header no longer carries the condition of the last branch (else). - A wildcard permission (
tabledata * = RIMD,codeunit * = X) is a
wildcard, not a reference to a missing object named*: no
unresolved-referencediagnostic, and it no longer counts as unresolved
inbca check. In the model its edge haswildcard: { type }instead of
unresolved: { name: "*", type }. Diagrams draw it to a node of its own
(table *) instead of "External / unresolved", the handbook lists it as
table *and knows thattabledata *covers every table, and the
dependency explorer and the knowledge graph no longer show an external
object*. A quoted"*"stays the name of an object. - The permission set of the warehouse example lacked Execute on the codeunit
that subscribes toOnRequestProcessed. The battle test found it: with
WAREHOUSE PROCESSalone, the Process action would have failed. bca run --tasksand the MCP toolbc_atlas_runaccept thehandbook
task, as.bca.jsontriggers already did.- The
headerof a procedure or trigger is its declaration line only:
local procedure Plain(var R: Record Customer): Boolean. It included the
varsection (... : Boolean var L: Integer), and a comment or#pragma
between the declaration and its variables orbegin. - A procedure or trigger whose body is split by
#if(procedure A()/
#if X/var ... begin ... end;/#else/begin end;/#endif, or
branches that open the body and share its end) has a body:hasBodyis
true, so it has a complexity and counts as code. It read as a declaration
without a body, with the whole body in itsheader. Its statements are one
condition with a path per branch, followed by what all branches share, so a
contract check sees it as conditional. Without the ...