Skip to content

Releases

v0.27.0

Choose a tag to compare

@github-actions github-actions released this 17 Nov 17:35
4e5a197

Added

  • The BC Atlas view as an MCP App. In a chat client that renders MCP
    Apps (Claude, ChatGPT, VS Code, Goose, ...) the MCP tool bc_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
    finer granularity every 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

Choose a tag to compare

@github-actions github-actions released this 17 Nov 11:16
6dbfbfc

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

Choose a tag to compare

@github-actions github-actions released this 17 Nov 10:19
f9395c7

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 --explain takes an
    object or a component, the report has Why these components, and the
    MCP tool bc_atlas_architecture_explain answers both for an agent.
  • Current and target architecture. bca architecture compare puts the
    architecture as it is (the namespaces, folders, and apps of the source, or
    what .bca.json configures) 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. --write makes 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> and architecture.goals weigh 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.json or in a file several repositories share.
    bca architecture templates lists, 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, and bc_atlas_architecture_adopt, and
    template, weights, and size on bc_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.naming renames
    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

Choose a tag to compare

@github-actions github-actions released this 17 Nov 05:12
8c9c44b

Added

  • Triggers of your own. A flow no longer runs on one of five triggers
    only: any other name under automation.triggers is a trigger of your own,
    started by pipeline events (push, pull-request, tag, release,
    manual, with branches, paths, and tags), by a cron, 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/--untrigger defines them, the builder has
    New trigger… and a form on every trigger node, bca setup keeps them
    and installs those that are a hook, and bca flow export writes 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 under layers in .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), titles and language (de: the headings,
    tables, and fixed texts in German), names (file and folder names by
    pattern; every link follows), and templates (a Markdown file per kind
    of page with placeholders for the title, the summary, the picture, and
    each section). Named
    profiles write several documentations from one source, each to a folder
    of its own: bca layers --profile <name>, the profile argument of
    bc_atlas_layers, and the option profile of a layers step 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-devops writes 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
    finding process-telemetry-uncertain says 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, and bca run
    are as before. An exported view (bca export --view app) is about 410 KB
    larger for it.

  • bca run --trigger and 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.json reads 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

Choose a tag to compare

@github-actions github-actions released this 15 Nov 11:48
c3e9cc2

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; or processTelemetry.appId and
      BCA_TELEMETRY_API_KEY to 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 --mine discovers 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 --adopt takes 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_process and bc_atlas_process_define.
    • Guide.
  • 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 as flow-changes.json.
    • The steps of a flow are a graph. A step can come after others
      ("id" and "after", or --id and --after), if each of them
      passed (the default), failed, or always. bca run runs 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 flow shows the flows and the catalog of artifacts
      (--artifacts); bca flow define changes them (--flow,
      --step, --to, --set, --at, --up, --down, --unstep,
      --remove, --deliver, --from). A flow that is not valid is never
      written.
    • bca run runs 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 pipeline bca setup writes 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 tool bc_atlas_flow_export.
    • The MCP tool bc_atlas_flow_define, and flows on bc_atlas_run.
    • Guide.

v0.22.0

Choose a tag to compare

@github-actions github-actions released this 12 Nov 14:49
7ed46e1

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 layers now
    answers these on two new pages. architecture.md shows 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.md lists 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 (changes in the
    atlas.json of the documentation): the story What to change, and
    how
    of the view walks through it on the graph, and
    bca view --story architecture prints 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.

  • bca without a command starts with where to begin.

  • Component nodes carry cohesion (how much of the coupling stays inside,
    in percent) and cycle; 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; --form and 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 view without --lens and with a picture or --inside shows the
    overview, no longer the System lens; --lens system gives that.
  • Object nodes of test codeunits carry test: true.

v0.21.0

Choose a tag to compare

@github-actions github-actions released this 11 Nov 15:08
189a37d

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.json names 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 tool bc_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 stories run:<person> of bca view and
    bc_atlas_view; in bca layers and bca bundle as 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

Choose a tag to compare

@github-actions github-actions released this 11 Nov 11:06
8225ef1

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.
      --check writes nothing and fails when the pages are behind the
      source. layers is a task of bca run, with layers.outputDir,
      pictures, history, and view in .bca.json.
    • The source as it was. --at <commit, tag, or release> records the
      same pages for that state below history/, read from a temporary
      checkout; --releases records every release not recorded yet.
      history/README.md lists 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 holds view.html, the BC Atlas view
      of it to open in a browser.
  • 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 plugin ai is 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 context prints 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 write writes 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-run says what would be
      written.
    • Settings: ai.endpoint, ai.model, ai.outputDir, ai.language in
      .bca.json, or BCA_AI_ENDPOINT and BCA_AI_MODEL. The key comes
      from BCA_AI_API_KEY only, never from a file.
    • The ai task of bca run, and the MCP tools bc_atlas_ai_context and
      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 as simulation-changes.json.
    • bca simulate define: --agent, --role, --task-group,
      --requirement with 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.
  • 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, or simulation.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 of bca view --form 3d show the same.

v0.19.0

Choose a tag to compare

@github-actions github-actions released this 11 Nov 06:46
e1842c7

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 file bca 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.
  • 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, --focus with
    --depth, --find, --hide, --off, --check, --story with
    --step, --stories, --color, --size, --group, and --format
    text, json, md, csv, svg, png, or link. 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 json prints the whole graph. One
    implementation draws the page and writes these files
    (src/app/ui/scene.js, graph.js). The MCP tool bc_atlas_view gives
    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, Backspace one step
    up. bca view --inside takes an app, a component, or a namespace too.
  • Plugins add to the graph. The new contribution atlas lets a plugin
    put nodes, relations, lenses, findings, and stories into the one graph;
    they show in the view, in bca view, in the MCP tool bc_atlas_view,
    and in every export, like those of BC Atlas. See
    What a plugin adds to the graph.
    bca view --lens accepts the lenses of plugins.
  • Recordings of Business Central are in the view. The built-in plugin
    sync adds 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-outdated on 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, and bca docs generate.
    --history no longer applies to bca export --view app.
  • Choosing a grouping for a proposed architecture in the app, and keeping a
    component or excluding an object from shaping. Set architecture.proposal
    in .bca.json or use bca architecture --propose.

v0.18.0

Choose a tag to compare

@github-actions github-actions released this 10 Nov 22:19
821b806

Added

  • Plugins (plugin API 1, docs): a plugin declares in
    plugin.json what it contributes — commands (bca <plugin> <command>),
    tasks for bca run (placed with before/after, outputs included in verify,
    stage, artifacts, and pull requests), health rules for bca 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, through activate(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 from BCA_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 into plugins/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, the sync task (before docs), the
    sync-outdated health rule, the bc_atlas_sync_status MCP tool, and the
    extension points sync.sources and sync.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 be Access = Internal. One box per object by default,
    --expand-procedures for every member inside its object, --focus for a
    part, --format json for the data points and uses. Also in
    bca export --view report --views ...,visibility and 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 simulate lets
    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 under simulation in .bca.json (roles,
    agents, taskGroups, requirements, mustNot for 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 of bca run (simulate, report in
    docs/simulation), a page of Docs in VS Code and the offline app, and
    the MCP tool bc_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" = Ri reads directly and inserts
    indirectly).

Changed

  • bca setup (and bca update, which runs setup apply --from-config) keeps
    the tasks it does not ask about in their triggers: plugin tasks, simulate,
    handbook, and diagrams were 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 properties are its own. The properties of a group, repeater,
    grid, cue group, action group, view, request page, rendering layout, field
    group, or modify(...) inside it no longer count as the object's, so the
    caption of a page is the page's Caption, not that of its last captioned
    group (the same for ApplicationArea, Editable, ToolTip, Visible,
    and SourceTableTemporary of 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
    conditionalSymbols names 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 an implements list, the record types of parameters, and a
    base object that differs by branch.
  • A relation found in the shared body after #endif of 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-reference diagnostic, and it no longer counts as unresolved
    in bca check. In the model its edge has wildcard: { 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 that tabledata * 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 to OnRequestProcessed. The battle test found it: with
    WAREHOUSE PROCESS alone, the Process action would have failed.
  • bca run --tasks and the MCP tool bc_atlas_run accept the handbook
    task, as .bca.json triggers already did.
  • The header of a procedure or trigger is its declaration line only:
    local procedure Plain(var R: Record Customer): Boolean. It included the
    var section (... : Boolean var L: Integer), and a comment or #pragma
    between the declaration and its variables or begin.
  • 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: hasBody is
    true, so it has a complexity and counts as code. It read as a declaration
    without a body, with the whole body in its header. 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 ...
Read more