bc-atlas 0.12.0 → 0.14.0

package/CHANGELOG.md

@@ -4,6 +4,63 @@ All notable changes to BC Atlas will be documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the project
 follows [Semantic Versioning](https://semver.org/).
 
+## 0.14.0 - 2026-11-05
+
+### Added
+
+- A root `.mcp.json` starts BC Atlas from the local checkout for direct MCP
+  tool calls in Copilot-compatible hosts. The MCP integration test uses the
+  same configuration, and the agent guide explains setup and server approval.
+
+### Fixed
+
+- Git-history analysis waits for its `git cat-file` reader to exit before
+  removing temporary snapshots, avoiding file-lock failures on Windows.
+
+## 0.13.0 - 2026-11-04
+
+### Added
+
+- `bca check` flags interface methods whose enum implementation can complete
+  silently: an empty body, a constant `true` return, or a conditional path
+  with no error (`contract-fallback`). Without configuration these are
+  informational; `check.contractExpectations` names the interface methods
+  that must not fall back silently and turns them into warnings. Unresolved
+  delegation, symbol-only bodies, and ambiguous signatures stay unknown
+  instead of counting as safe. See [Configuration](./docs/configuration.md).
+- `check.contexts` summarizes the responsibilities of selected objects:
+  reads, persistent and temporary writes, commits, resolved calls, and global
+  state, direct and up to `maxCallDepth` calls away. `roles`,
+  `lazyReadMethods`, and `forbid` turn them into policy warnings; bounded or
+  unresolved evidence is reported with its limitations.
+- Architecture component selectors accept `file:` (one file, globs allowed),
+  more specific than a namespace, folder, or ID range.
+- Enum bindings keep `DefaultImplementation` and `UnknownValueImplementation`
+  as evidence, and calls keep their arguments.
+
+### Changed
+
+- Health and architecture findings carry their basis (`configured-policy`,
+  `observed-code-fact`, or `heuristic` for a proposed architecture), a
+  primary location, all evidence, and limitations. Text and Markdown show up
+  to five locations; JSON and SARIF keep everything.
+- Component cycles are explained by a representative path with the
+  dependencies behind each hop, and, where several providers call back into
+  the same orchestrator procedure, suggest extracting a shared service.
+- `bca refactor move` defaults to the common parent folder of a component's
+  objects instead of the folder most of them are in.
+- Records of pages and tables with `SourceTableTemporary` count as temporary,
+  and record parameters of unknown temporariness are no longer reported as
+  persistent writes.
+- Release: one *Release* workflow publishes the npm package and the VS Code
+  extension under one version, after testing both, and attaches the `.vsix`
+  to the GitHub release.
+
+### Fixed
+
+- Health reports no longer print `architecture origin: undefined`, and
+  Markdown evidence cells with `|` no longer break the table.
+
 ## 0.12.0 - 2026-10-29
 
 ### Added

package/README.md

@@ -44,7 +44,7 @@ In VS Code, install the **BC Atlas** extension and open an AL project:
 | **Export** | `bca export` | Everything the extension shows, as files: the BC Atlas pages as one offline HTML file to share (default), the Markdown report ([example](./examples/report/README.md)), the 3D explorer, one Markdown page per object, any of ten diagram views as D2, SVG, PNG, PDF, or JSON, with `--watch`, and the project as a knowledge graph in RDF with an OWL ontology ([Turtle, RDF/XML, OWL, N-Triples, JSON-LD](./docs/knowledge-graph.md)). |
 | | `bca docs` | User guides and test cases from AL UI tests (`[SCENARIO]`, `[GIVEN]`, `[WHEN]`, `[THEN]`) as Markdown, HTML, DITA 1.3, or Azure DevOps CSV, with real captions and translations, a flow diagram per scenario, and BPMN 2.0 processes per use case. [Example](./examples/docs/index.md) |
 | **Integrate** | `bca run` | One entry point for Git hooks, schedules, and pipelines; verifies, stages, or publishes generated files. Also available as a [GitHub Action](./docs/automation-and-ci.md#github-actions). |
-| | `bca update` | "BC Atlas 0.13.0 is available": release notes, one-step update, and regenerated hooks, tasks, and pipelines. Dependabot pull requests on request. |
+| | `bca update` | "BC Atlas 0.14.0 is available": release notes, one-step update, and regenerated hooks, tasks, and pipelines. Dependabot pull requests on request. |
 | | `bca mcp` | A Model Context Protocol server for AI agents; `bca help --format json` is the versioned command contract. |
 
 Run `bca` for the same overview in your terminal and `bca help <command>` for
@@ -259,27 +259,25 @@ lists planned work.
 
 ### Publishing
 
-Releases are published manually through the `Publish npm package` workflow.
-Update and commit the version in `package.json` and `package-lock.json`, then
-enter that exact version in the workflow form. The workflow rejects mismatched
-or already published versions, runs all checks, and publishes with the selected
-dist-tag. It then tags the commit as `v<version>`, so
+Releases are published manually through the `Release` workflow
+(`.github/workflows/publish-npm.yml`). Set the version of both packages with
+`npm run version:set -- <version>`, merge it, then run the workflow on `main`
+with that exact version. It rejects mismatched, already published, or already
+tagged versions, and tests the npm package and the VS Code extension, the
+packaged `.vsix` included, before anything is published. Then it publishes the
+npm package with the selected dist-tag and, unless switched off, the extension
+to the Visual Studio Marketplace and, with the secret `OVSX_PAT`, to Open VSX.
+Last, it tags the commit as `v<version>`, so
 `uses: SchulzOli/BC-Atlas@v<version>` resolves, and creates a GitHub release
-with the version's `CHANGELOG.md` section. npm authenticates through
+with the version's `CHANGELOG.md` section and the `.vsix`.
+
+No token is stored for either registry. npm authenticates through
 [trusted publishing](https://docs.npmjs.com/trusted-publishers): the package's
 trusted publisher on npmjs.com is this repository's `publish-npm.yml`
-workflow, so no npm token is stored in GitHub.
-
-
-The VS Code extension in `vscode/` is published by the `Publish VS Code
-extension` workflow: set `version` in `vscode/package.json`, then run the
-workflow with that version. It tests and packages the extension with the
-current engine and publishes it to the Visual Studio Marketplace as the
-publisher `SchulzOli`, signed in with Microsoft Entra ID through GitHub's OIDC
-token (no Marketplace token is stored; see the
-[launch checklist](https://github.com/SchulzOli/BC-Atlas/blob/main/vscode/marketing/README.md#launch-checklist)), and, with
-the secret `OVSX_PAT`, to Open VSX. Every CI run uploads the `.vsix` as the
-`bc-atlas-vsix` artifact.
+workflow. The Marketplace publisher `SchulzOli` is signed in with Microsoft
+Entra ID through GitHub's OIDC token in the `marketplace` environment (see the
+[launch checklist](https://github.com/SchulzOli/BC-Atlas/blob/main/vscode/marketing/README.md#launch-checklist)).
+Every CI run uploads the `.vsix` as the `bc-atlas-vsix` artifact.
 
 ## Contributing and support
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bc-atlas",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "BC Atlas maps Microsoft Dynamics 365 Business Central AL projects: architecture diagrams, health checks, reports, and documentation generated from source.",
   "homepage": "https://github.com/SchulzOli/BC-Atlas#readme",
   "bugs": {

package/src/analyzer.js

@@ -293,10 +293,18 @@ function enclosingMember(node, source, types) {
   return undefined;
 }
 
-function implementationRelations(value, node, source, add) {
+function implementationRelations(property, value, node, source, add) {
+  const bindingKind = {
+    implementation: "explicit",
+    defaultimplementation: "default",
+    unknownvalueimplementation: "unknownValue"
+  }[property];
+  if (!bindingKind) return;
   const identifier = String.raw`(?:"((?:""|[^"])*)"|([A-Za-z_][\w.]*))`;
   const pattern = new RegExp(`${identifier}\\s*=\\s*${identifier}`, "gu");
-  const member = enclosingMember(node, source, ["enum_value_declaration"]);
+  const member = bindingKind === "explicit"
+    ? enclosingMember(node, source, ["enum_value_declaration"])
+    : undefined;
   for (const match of value.matchAll(pattern)) {
     const contract = (match[1] ?? match[2]).replaceAll('""', '"');
     const target = (match[3] ?? match[4]).replaceAll('""', '"');
@@ -304,6 +312,7 @@ function implementationRelations(value, node, source, add) {
       target,
       targetType: "codeunit",
       kind: "selects",
+      bindingKind,
       contract,
       member
     });
@@ -496,8 +505,8 @@ function referencesFor(objectNode, source, file) {
       if (name === "includedpermissionsets") {
         includedPermissionSetRelations(value, node, add);
       }
-      if (name === "implementation") {
-        implementationRelations(value, node, source, add);
+      if (["implementation", "defaultimplementation", "unknownvalueimplementation"].includes(name)) {
+        implementationRelations(name, value, node, source, add);
       }
       if (name === "runobject") {
         const match = value.match(
@@ -533,6 +542,9 @@ function callsFor(node, source, file) {
       ? functionNode.childForFieldName("object")
       : undefined;
     const argumentsNode = callNode.childForFieldName("arguments");
+    const argumentsList = argumentsNode?.namedChildren.map((argument) =>
+      source.slice(argument.startIndex, argument.endIndex).trim()
+    ) ?? [];
     return {
       name: cleanName(source.slice(
         (memberNode ?? functionNode).startIndex,
@@ -543,6 +555,7 @@ function callsFor(node, source, file) {
         : undefined,
       receiverCall: receiverNode?.type === "call_expression" ? describe(receiverNode) : undefined,
       arity: argumentsNode?.namedChildCount ?? 0,
+      ...(argumentsList.length ? { arguments: argumentsList } : {}),
       scope: node.startPosition.row + 1,
       location: locationFor(callNode, file)
     };
@@ -610,6 +623,149 @@ function variableType(node, source) {
   return declaredType(type);
 }
 
+function fallbackStatements(node, source, file, conditional = false) {
+  if (!node) return [];
+  if (node.type === "statement_block") {
+    return node.namedChildren.flatMap((child) =>
+      fallbackStatements(child, source, file, conditional)
+    );
+  }
+  if (node.type === "if_statement") {
+    return [{
+      kind: "conditional",
+      then: fallbackStatements(node.childForFieldName("then_branch"), source, file, true),
+      else: node.childForFieldName("else_branch")
+        ? fallbackStatements(node.childForFieldName("else_branch"), source, file, true)
+        : null,
+      location: locationFor(node, file)
+    }];
+  }
+  if (node.type === "case_statement") {
+    const body = node.childForFieldName("body");
+    const branches = (body?.namedChildren ?? [])
+      .filter((child) => child.type === "case_branch")
+      .map((branch) => fallbackStatements(
+        branch.childForFieldName("body"),
+        source,
+        file,
+        true
+      ));
+    const elseBranch = node.namedChildren.find((child) => child.type === "case_else_branch");
+    if (elseBranch) {
+      branches.push(elseBranch.namedChildren
+        .filter((child) => child.type !== "else_keyword")
+        .flatMap((child) => fallbackStatements(child, source, file, true)));
+    }
+    return [{
+      kind: "conditional",
+      branches,
+      hasImplicitEmptyPath: !elseBranch,
+      location: locationFor(node, file)
+    }];
+  }
+  if (["while_statement", "for_statement", "repeat_statement"].includes(node.type)) {
+    const body = node.childForFieldName("body");
+    return [{
+      kind: "conditional",
+      branches: [fallbackStatements(body, source, file, true)],
+      hasImplicitEmptyPath: node.type !== "repeat_statement",
+      location: locationFor(node, file)
+    }];
+  }
+  if (node.type === "call_expression") {
+    const functionNode = node.childForFieldName("function");
+    const memberNode = functionNode?.type === "member_expression"
+      ? functionNode.childForFieldName("member")
+      : undefined;
+    const receiverNode = functionNode?.type === "member_expression"
+      ? functionNode.childForFieldName("object")
+      : undefined;
+    const target = functionNode
+      ? cleanName(source.slice(
+        (memberNode ?? functionNode).startIndex,
+        (memberNode ?? functionNode).endIndex
+      ))
+      : undefined;
+    const argumentsNode = node.childForFieldName("arguments");
+    return [{
+      kind: "call",
+      target,
+      receiver: receiverNode
+        ? cleanName(source.slice(receiverNode.startIndex, receiverNode.endIndex))
+        : undefined,
+      arity: argumentsNode?.namedChildCount ?? 0,
+      directError: !receiverNode && target?.toLocaleLowerCase("en-US") === "error",
+      conditional,
+      location: locationFor(node, file)
+    }];
+  }
+  if (node.type === "exit_statement") {
+    const returnNode = node.childForFieldName("return_value");
+    return [{
+      kind: "return",
+      value: returnNode ? source.slice(returnNode.startIndex, returnNode.endIndex).trim() : undefined,
+      constant: Boolean(returnNode && [
+        "boolean",
+        "integer",
+        "decimal",
+        "string_literal"
+      ].includes(returnNode.type)),
+      conditional,
+      location: locationFor(node, file)
+    }];
+  }
+  if (node.type === "assignment_statement") {
+    const targetNode = node.childForFieldName("left");
+    return [{
+      kind: "assignment",
+      target: targetNode
+        ? cleanName(source.slice(targetNode.startIndex, targetNode.endIndex))
+        : undefined,
+      conditional,
+      location: locationFor(node, file)
+    }];
+  }
+  return [{
+    kind: "other",
+    conditional,
+    location: locationFor(node, file)
+  }];
+}
+
+function fallbackFactsFor(node, source, file, hasBody) {
+  if (!hasBody) return undefined;
+  const codeBlock = node.namedChildren.find((child) =>
+    ["code_block", "statement_block"].includes(child.type)
+  );
+  const body = codeBlock?.childForFieldName("body") ??
+    codeBlock?.namedChildren.find((child) => child.type === "statement_block");
+  return {
+    complete: !node.hasError && !codeBlock?.hasError,
+    statements: fallbackStatements(body, source, file),
+    ...((node.hasError || codeBlock?.hasError)
+      ? { limitations: ["The AL parser reported errors in this procedure body."] }
+      : {})
+  };
+}
+
+function resolveFallbackCalls(statements, procedures) {
+  for (const statement of statements) {
+    if (statement.kind === "conditional") {
+      if (statement.then) resolveFallbackCalls(statement.then, procedures);
+      if (statement.else) resolveFallbackCalls(statement.else, procedures);
+      for (const branch of statement.branches ?? []) {
+        resolveFallbackCalls(branch, procedures);
+      }
+      continue;
+    }
+    if (statement.kind !== "call" || statement.directError) continue;
+    const candidates = procedures.get(`${statement.target?.toLocaleLowerCase("en-US")}:${statement.arity}`) ?? [];
+    const target = !statement.receiver && candidates.length === 1 ? candidates[0] : undefined;
+    statement.resolved = Boolean(target?.fallbackFacts?.complete);
+    if (target) statement.targetSignature = target.signature;
+  }
+}
+
 function membersFor(objectNode, source, file) {
   const procedures = [];
   const fields = [];
@@ -624,18 +780,24 @@ function membersFor(objectNode, source, file) {
       const name = fieldText(node, "name", source);
       if (name) {
         const returnTypeNode = node.childForFieldName("return_type");
-        const returnType = returnTypeNode
-          ? declaredType(source.slice(returnTypeNode.startIndex, returnTypeNode.endIndex).trim())
-          : {};
+        const header = procedureHeader(node, source);
+        const returnTypeText = returnTypeNode
+          ? source.slice(returnTypeNode.startIndex, returnTypeNode.endIndex).trim()
+          : header.match(/\)\s*:\s*([^;\r\n]+)$/u)?.[1]?.trim();
+        const returnType = declaredType(returnTypeText);
         const attributes = [
           ...node.namedChildren
           .filter((child) => child.type === "attribute_item")
           .map((child) => source.slice(child.startIndex, child.endIndex)),
           ...attributesFor(node, source)
         ];
+        const hasBody = node.namedChildren.some((child) =>
+          ["code_block", "statement_block"].includes(child.type)
+        );
+        const fallbackFacts = fallbackFactsFor(node, source, file, hasBody);
         procedures.push({
           name,
-          header: procedureHeader(node, source),
+          header,
           visibility: node.type === "trigger_declaration"
             ? undefined
             : fieldText(node, "modifier", source)?.toLowerCase() ?? "public",
@@ -647,6 +809,8 @@ function membersFor(objectNode, source, file) {
               : attributes.some((attribute) => /\[(?:Integration|Business)Event\b/iu.test(attribute))
                 ? "event"
               : "procedure",
+          hasBody,
+          ...(fallbackFacts ? { fallbackFacts } : {}),
           location: locationFor(node, file),
           calls: callsFor(node, source, file),
           attributes,
@@ -825,6 +989,18 @@ function membersFor(objectNode, source, file) {
       .map(({ order, location }) => ({ kind: "commit", order, location }));
     procedure.transactionSegments = procedure.transactionBoundaries.length + 1;
   }
+  const localProcedures = new Map();
+  for (const procedure of procedures) {
+    const key = `${procedure.name.toLocaleLowerCase("en-US")}:${procedure.arity}`;
+    const candidates = localProcedures.get(key) ?? [];
+    candidates.push(procedure);
+    localProcedures.set(key, candidates);
+  }
+  for (const procedure of procedures) {
+    if (procedure.fallbackFacts) {
+      resolveFallbackCalls(procedure.fallbackFacts.statements, localProcedures);
+    }
+  }
   const transactionBoundaries = procedures.flatMap((procedure) =>
     procedure.transactionBoundaries.map((boundary) => ({
       ...boundary,
@@ -854,8 +1030,8 @@ function dataOperationRelations(members, object) {
         .map((variable) => [variable.name.toLowerCase(), variable])
     );
     if (sourceTable) {
-      variables.set("rec", { target: sourceTable, temporary: false });
-      variables.set("xrec", { target: sourceTable, temporary: false });
+      variables.set("rec", { target: sourceTable, temporary: object.sourceTableTemporary });
+      variables.set("xrec", { target: sourceTable, temporary: object.sourceTableTemporary });
     }
     let transactionSegment = 1;
     for (const call of procedure.calls) {
@@ -874,7 +1050,10 @@ function dataOperationRelations(members, object) {
         kind,
         relationClass: "runtime",
         operation: call.name,
-        temporary: variable.temporary,
+        recordVariable: call.receiver,
+        temporary: variable.parameter && variable.temporary !== true
+          ? undefined
+          : variable.temporary,
         member: procedure.signature,
         sourceProcedure: procedure.signature,
         transactionSegment,
@@ -885,6 +1064,24 @@ function dataOperationRelations(members, object) {
   return relations;
 }
 
+function subscriberRelations(procedures) {
+  const relations = [];
+  for (const procedure of procedures) {
+    for (const attribute of procedure.attributes ?? []) {
+      const match = attribute.match(/^\[\s*EventSubscriber\s*\(\s*ObjectType::(Codeunit|Table|Page|Report|XmlPort)\s*,\s*(?:Codeunit|Database|Page|Report|XmlPort)::\s*(?:"((?:""|[^"])*)"|([^,\]\s]+))/iu);
+      if (!match) continue;
+      relations.push({
+        target: (match[2] ?? match[3]).replaceAll('""', '"'),
+        targetType: match[1].toLowerCase(),
+        kind: "subscribes",
+        member: procedure.name,
+        location: procedure.location
+      });
+    }
+  }
+  return relations;
+}
+
 function helperDataOperationRelations(members, directRelations) {
   const procedures = new Map();
   for (const procedure of members.procedures) {
@@ -971,7 +1168,18 @@ async function objectsFromSource(source, file) {
       });
     }
     const members = membersFor(node, source, file);
-    const dataRelations = dataOperationRelations(members, { type, name, base, relations });
+    const properties = propertiesFor(node, source);
+    const sourceTableTemporary = /^true$/iu.test(
+      propertyValueFor(node, source, "sourcetabletemporary") ?? "false"
+    );
+    relations.push(...subscriberRelations(members.procedures));
+    const dataRelations = dataOperationRelations(members, {
+      type,
+      name,
+      base,
+      relations,
+      sourceTableTemporary
+    });
     relations.push(...dataRelations, ...helperDataOperationRelations(members, dataRelations));
 
     const assignableValue = type === "permissionset"
@@ -987,7 +1195,7 @@ async function objectsFromSource(source, file) {
       namespace,
       usings,
       file,
-      properties: propertiesFor(node, source),
+      properties,
       relations,
       procedures: members.procedures,
       fields: members.fields,

package/src/blueprint/components.js

@@ -2,10 +2,11 @@ import { normalizeIdentifier } from "../resolver.js";
 
 // A component is a named part of the target architecture (a future app, or a
 // layer inside one). Objects are assigned by selectors; the most specific
-// matching selector wins (object, then the longest namespace or folder, then
-// the narrowest ID range, then module and app, then type, then *):
+// matching selector wins (object, then file, then the longest namespace or
+// folder, then the narrowest ID range, then module and app, then type, then *):
 //   namespace:Contoso.Sales      the namespace and everything below it
 //   folder:src/Sales             files below a folder (globs allowed)
+//   file:src/Sales/Order.al       one file (globs allowed)
 //   app:Contoso Sales            an app by name or ID
 //   module:Job Queue             a module (nested app.json) by name or ID
 //   type:table                   an object type
@@ -52,7 +53,7 @@ function compileSingle(selector, { apps, modules, componentOf, layerOf }) {
   if (text === "*" || text === "**") return () => 1;
   const separator = text.indexOf(":");
   if (separator < 1) {
-    throw new Error(`Invalid component selector "${text}"; use namespace:, folder:, app:, module:, type:, object:, id:, or *`);
+    throw new Error(`Invalid component selector "${text}"; use namespace:, folder:, file:, app:, module:, type:, object:, id:, or *`);
   }
   const kind = text.slice(0, separator).toLowerCase();
   const value = text.slice(separator + 1).trim();
@@ -80,6 +81,15 @@ function compileSingle(selector, { apps, modules, componentOf, layerOf }) {
     }
     return (node) => Boolean(node.file) && (node.file === folder || node.file.startsWith(`${folder}/`)) && specificity;
   }
+  if (kind === "file") {
+    const file = value.replaceAll("\\", "/").replace(/^\.?\//u, "");
+    const specificity = 200 + file.replaceAll("*", "").replaceAll("?", "").length;
+    const expression = isGlob(file) ? globToRegExp(file) : undefined;
+    return (node) => {
+      const candidate = String(node.file ?? "").replaceAll("\\", "/");
+      return (expression ? expression.test(candidate) : candidate === file) && specificity;
+    };
+  }
   if (kind === "app") {
     return (node) => {
       const app = apps.get(node.app);
@@ -118,7 +128,7 @@ function compileSingle(selector, { apps, modules, componentOf, layerOf }) {
     return (node) => (!type || node.type === type.toLowerCase()) &&
       [node.label, node.objectId].filter(Boolean).some((candidate) => normalizeIdentifier(candidate) === name) && 1000;
   }
-  throw new Error(`Unsupported selector kind "${kind}"; use namespace, folder, app, module, type, object, or id${componentOf ? ", component, or layer" : ""}`);
+  throw new Error(`Unsupported selector kind "${kind}"; use namespace, folder, file, app, module, type, object, or id${componentOf ? ", component, or layer" : ""}`);
 }
 
 /** Apps and modules by id, for selectors that name them. */