d365fo-mcp 1.13.0 → 1.15.0

package/.github/copilot-instructions.md

@@ -32,7 +32,7 @@ PowerShell / any terminal command **WILL HANG** in VS 2022 / VS 2026 MCP integra
 | Plan a new object before creating it | `prepare(mode="create", goal, objectName, objectType)` — returns collision check, naming, EDT/label hints + `groundingToken` |
 | Create a D365FO object | `d365fo_file(action="create")` (never `create_file`) |
 | Edit an existing object | `d365fo_file(action="modify")` (applies immediately — confirm in chat first) |
-| Revert the last write | `undo_last_modification` |
+| Revert the last write | `d365fo_file(action="undo", filePath)` — git-tracked → checkout HEAD (discards ALL uncommitted changes to that file); untracked → deleted |
 | Search objects | `search` — multiple via `search(queries[])`, custom-only via `search(scope="extensions")` |
 | Read any object's metadata | `get_object_info(objectType, name, options?)` — objectType ∈ class/table/form/query/view/enum/edt/report/data-entity/menu-item/service/map/config-key/security-policy/macro. 2+ known names: `get_object_info(objects=[{objectType,objectName},…])` — ONE call, never a loop |
 | Method signature for CoC | `get_object_info(objectType="class", name, options={method, include:"signature"})` (already returned by `prepare(mode="change")`) |
@@ -41,7 +41,7 @@ PowerShell / any terminal command **WILL HANG** in VS 2022 / VS 2026 MCP integra
 | Create a NEW form | `object_patterns(domain="form", action="analyze", recommend={...})` → `object_patterns(domain="form", action="spec", pattern)` → `generate_object(mode="scaffold", objectType="form", cloneFrom=referenceForm, tableMapping={...})` → `object_patterns(domain="form", action="validate", xml)` |
 | Validate form XML against its pattern | `object_patterns(domain="form", action="validate", xml \| formName \| filePath)` — structural errors block form writes (FORM_PATTERN_ENFORCE) |
 | Resolve label / EDT / class refs | `validate_code(mode="references", code)` |
-| Build / BP / Sync | `build_d365fo_project` / `run_bp_check` / `trigger_db_sync` |
+| Build / BP / Sync | `build_d365fo_project(bpCheck: true, dbSync: true)` — ONE call compiles, runs the best-practice check and syncs AxDB |
 | Error diagnosis | `get_knowledge(kind="error", errorText)` |
 | Parameters for a `d365fo_file` operation / `generate_object` mode | `get_knowledge(kind="op-spec", topic="add-index" \| "table" \| "scaffold:form")` — those two tools keep their parameters OUT of the tool schema; look the contract up once for the operation you picked, then nest the values in `params` (`properties` for `action="create"`) |
 
@@ -53,7 +53,7 @@ PowerShell / any terminal command **WILL HANG** in VS 2022 / VS 2026 MCP integra
 
 ### Writes & file editing
 
-2. **`d365fo_file` (action=create/modify) applies immediately** (no dry-run / preview). Describe the change in chat and wait for explicit user confirmation ("apply", "ok", "yes") before calling. Revert with `undo_last_modification` (or pass `createBackup=true` to keep a `.bak`).
+2. **`d365fo_file` (action=create/modify) applies immediately** (no dry-run / preview). Describe the change in chat and wait for explicit user confirmation ("apply", "ok", "yes") before calling. Revert with `d365fo_file(action="undo")` (or pass `createBackup=true` to keep a `.bak`).
 3. **Never** use `replace_string_in_file`, `edit_file`, `apply_patch`, or any built-in file-write tool on `.xml` or `.xpp` files — **not even as a fallback** when `d365fo_file(action="modify")` fails. These bypass `IMetadataProvider` and corrupt VS 2022's in-memory model. If `d365fo_file(action="modify")` errors, STOP and report the error verbatim.
 
 ### Build automation
@@ -78,7 +78,7 @@ PowerShell / any terminal command **WILL HANG** in VS 2022 / VS 2026 MCP integra
 ### Reuse & diff safety
 
 10. **Reuse before creating** — `prepare(mode="change")` lists existing CoC wrappers and event handlers. If an extension or handler class in the custom model already owns the target, add the new method there. Never create a parallel feature-named class (`<Target>_<Feature>_Extension`, `<Form>_<Feature>_EH`) unless the user explicitly asks for a separate class. The suffix comes from `EXTENSION_NAMING_STYLE` / existing artifacts — never from feature, ticket, or customer names; if it cannot be derived, ask.
-11. **The post-write diff must be additive or narrowly targeted** — verify via `review_workspace_changes` (or re-read with `get_*_info`) that no unrelated XML nodes (`<DataSources>`, `<Controls>`, methods, pattern metadata) disappeared. If they did, the edit failed: `undo_last_modification`.
+11. **The post-write diff must be additive or narrowly targeted** — verify via `get_workspace_info(changes=true)` (or re-read with `get_object_info`) that no unrelated XML nodes (`<DataSources>`, `<Controls>`, methods, pattern metadata) disappeared. If they did, the edit failed: `d365fo_file(action="undo")`.
 12. **An example form named by the user is a pattern contract** — keep its pattern family and required scaffolding (datasources, ActionPane/Tab/grid/QuickFilter); missing pattern elements are a failed generation even if the XML is well-formed.
 
 ### Spending tool calls

package/README.md

@@ -2,13 +2,13 @@
 
 <div align="center">
 
-**23 AI tools that know every X++ class, table, form, and EDT in your D365FO codebase**
+**20 AI tools that know every X++ class, table, form, and EDT in your D365FO codebase**
 
 [![npm](https://img.shields.io/npm/v/d365fo-mcp.svg?logo=npm&color=cb3837)](https://www.npmjs.com/package/d365fo-mcp)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Node.js](https://img.shields.io/badge/node-%3E%3D24.0.0-brightgreen.svg)](https://nodejs.org/)
 [![TypeScript](https://img.shields.io/badge/TypeScript-7.0-blue.svg)](https://www.typescriptlang.org/)
-[![Tests](https://img.shields.io/badge/tests-2800%2B-brightgreen.svg)](docs/TESTING.md)
+[![Tests](https://img.shields.io/badge/tests-5000%2B-brightgreen.svg)](docs/TESTING.md)
 <!-- coverage-badge:start -->
 [![Core coverage](https://img.shields.io/badge/core_coverage-100%25-brightgreen.svg)](eval/COVERAGE.md) [![Total coverage](https://img.shields.io/badge/total_coverage-100%25-lightgrey.svg)](eval/COVERAGE.md)
 <!-- coverage-badge:end -->
@@ -29,7 +29,7 @@
 
 AI assistants excel at C#, Python, and JavaScript. X++ is different: your D365FO codebase is private, deeply customized, and invisible to every model — so AI confidently generates code that doesn't compile.
 
-This server pre-indexes your entire D365FO installation (580 000+ symbols across standard, ISV, and custom models) and exposes it as 23 specialized MCP tools. Every signature, every CoC wrapper, every label, every form pattern — verified against your real metadata **before** the AI writes a single line.
+This server pre-indexes your entire D365FO installation (580 000+ symbols across standard, ISV, and custom models) and exposes it as 20 specialized MCP tools. Every signature, every CoC wrapper, every label, every form pattern — verified against your real metadata **before** the AI writes a single line.
 
 ![Solution Architecture](docs/img/solution-architecture-diagram.svg)
 
@@ -115,7 +115,7 @@ Deployment guide: [docs/SETUP_AZURE.md](docs/SETUP_AZURE.md) — includes CI/CD
 
 | Getting started | Reference | Operations |
 |-----------------|-----------|------------|
-| [Quick Start](docs/QUICK_START.md) — connect or install | [All 23 tools](docs/MCP_TOOLS.md) | [Azure deployment](docs/SETUP_AZURE.md) |
+| [Quick Start](docs/QUICK_START.md) — connect or install | [All 20 tools](docs/MCP_TOOLS.md) | [Azure deployment](docs/SETUP_AZURE.md) |
 | [Setup scenarios A–F](docs/SETUP.md) | [`.mcp.json` reference](docs/MCP_CONFIG.md) | [DevOps pipelines](docs/SETUP_AZURE.md#azure-devops-pipelines) |
 | [Claude Code setup](docs/SETUP.md#claude-code-cli) | [Configuration](docs/CONFIGURATION.md) | [Testing](docs/TESTING.md) |
 | [Usage examples](docs/USAGE_EXAMPLES.md) — real tool chains | [Architecture](docs/ARCHITECTURE.md) | [Custom / ISV models](docs/CUSTOM_EXTENSIONS.md) |

package/bridge/D365MetadataBridge/Models/Models.cs

@@ -255,6 +255,18 @@ namespace D365MetadataBridge.Models
         [JsonPropertyName("extends")]
         public string? Extends { get; set; }
 
+        /// <summary>
+        /// Root of the Extends chain. Reported for orientation in a multi-level hierarchy; it is
+        /// not necessarily the element that declares the StringSize -- see StringSizeInheritedFrom
+        /// for that.
+        ///
+        /// Null for a root EDT, and also null when the chain could not be walked to its end -- a
+        /// dangling Extends or a cycle -- because the last ancestor reached is not the root and
+        /// naming it as one would be a wrong answer rather than a missing one.
+        /// </summary>
+        [JsonPropertyName("rootEdt")]
+        public string? RootEdt { get; set; }
+
         [JsonPropertyName("label")]
         public string? Label { get; set; }
 
@@ -264,6 +276,14 @@ namespace D365MetadataBridge.Models
         [JsonPropertyName("stringSize")]
         public int? StringSize { get; set; }
 
+        /// <summary>
+        /// Ancestor the reported StringSize came from. Null when the number is what this EDT's
+        /// own XML declares. Set both when the EDT declares nothing (the common case) and when
+        /// an ancestor's value overrode one the EDT did declare.
+        /// </summary>
+        [JsonPropertyName("stringSizeInheritedFrom")]
+        public string? StringSizeInheritedFrom { get; set; }
+
         [JsonPropertyName("referenceTable")]
         public string? ReferenceTable { get; set; }
 

package/bridge/D365MetadataBridge/Program.cs

@@ -1,9 +1,11 @@
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Text.Json;
+using System.Threading;
 using System.Threading.Tasks;
 using D365MetadataBridge.Protocol;
 
@@ -219,9 +221,33 @@ namespace D365MetadataBridge
             }
         }
 
+        /// <summary>
+        /// How many reads may be inside the provider at once. Bounded on purpose: the
+        /// win is in overlapping a handful of fan-out reads, not in handing an unbounded
+        /// number of threads to a metadata provider whose thread-safety is undocumented.
+        /// </summary>
+        private const int ReadSlots = 6;
+
+        /// <summary>
+        /// A read takes one slot; anything else takes ALL of them, which is what makes a
+        /// write or a provider refresh exclusive against every in-flight read. Simple
+        /// enough to reason about without an async reader/writer lock.
+        ///
+        /// A writer waits for the slots, so a continuous stream of reads could delay it.
+        /// In practice requests come from one MCP client that awaits its own calls, so
+        /// there is no such stream.
+        /// </summary>
+        private static readonly SemaphoreSlim _slots = new SemaphoreSlim(ReadSlots, ReadSlots);
+
+        /// <summary>stdout is one stream: concurrent handlers must not interleave lines on it.</summary>
+        private static readonly SemaphoreSlim _stdoutLock = new SemaphoreSlim(1, 1);
+        private static readonly StreamWriter _stdout =
+            new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = true };
+
         private static async Task<int> RunStdioLoop(RequestDispatcher dispatcher)
         {
             var reader = new StreamReader(Console.OpenStandardInput());
+            var inFlight = new List<Task>();
 
             string? line;
             while ((line = await reader.ReadLineAsync()) != null)
@@ -229,45 +255,127 @@ namespace D365MetadataBridge
                 if (string.IsNullOrWhiteSpace(line))
                     continue;
 
-                BridgeResponse response;
+                BridgeRequest? request = null;
                 try
                 {
-                    var request = JsonSerializer.Deserialize<BridgeRequest>(line, JsonOptions.Default);
-                    if (request == null || string.IsNullOrEmpty(request.Method))
-                    {
-                        response = BridgeResponse.CreateError("?", -32600, "Invalid request");
-                    }
-                    else
-                    {
-                        Log.WriteLine($"[DEBUG] → {request.Method} (id={request.Id})");
-                        response = await dispatcher.Dispatch(request);
-                        Log.WriteLine($"[DEBUG] ← {request.Method} OK (id={request.Id})");
-                    }
+                    request = JsonSerializer.Deserialize<BridgeRequest>(line, JsonOptions.Default);
                 }
                 catch (JsonException ex)
                 {
                     Log.WriteLine($"[ERROR] JSON parse error: {ex.Message}");
-                    response = BridgeResponse.CreateError("?", -32700, $"Parse error: {ex.Message}");
+                    await WriteResponse(BridgeResponse.CreateError("?", -32700, $"Parse error: {ex.Message}"));
+                    continue;
                 }
-                catch (Exception ex)
+
+                if (request == null || string.IsNullOrEmpty(request.Method))
                 {
-                    Log.WriteLine($"[ERROR] Unhandled: {ex.Message}\n{ex.StackTrace}");
-                    response = BridgeResponse.CreateError("?", -32603, $"Internal error: {ex.Message}");
+                    await WriteResponse(BridgeResponse.CreateError("?", -32600, "Invalid request"));
+                    continue;
                 }
 
-                await WriteResponse(response);
+                // Reads go to the thread pool so the loop can read the next line at once;
+                // everything else keeps the original behaviour of running to completion
+                // before the next request is even parsed.
+                if (RequestDispatcher.IsConcurrentSafeRead(request.Method))
+                {
+                    // Touch Exception on a faulted task before dropping it, so the fault
+                    // is observed rather than left for the finalizer — a task pruned here
+                    // is never awaited anywhere else.
+                    inFlight.RemoveAll(t =>
+                    {
+                        if (t.IsFaulted) { var _ = t.Exception; }
+                        return t.IsCompleted;
+                    });
+                    inFlight.Add(HandleConcurrently(dispatcher, request));
+                }
+                else
+                {
+                    // Drain the reads already running, then take every slot: a write or a
+                    // provider rebuild must not overlap a read of the provider it replaces.
+                    if (inFlight.Count > 0)
+                    {
+                        // Guarded. DispatchGuarded turns any handler escape into a
+                        // response, so the only realistic thrower left is WriteResponse on
+                        // a broken stdout — and an unguarded WhenAll rethrows that HERE,
+                        // out of RunStdioLoop and out of Main, killing the bridge because
+                        // an unrelated read could not print. The final drain below was
+                        // already written this way; this one was not.
+                        try { await Task.WhenAll(inFlight); }
+                        catch { /* each read already answered, or failed on its own */ }
+                        inFlight.Clear();
+                    }
+                    for (var i = 0; i < ReadSlots; i++) await _slots.WaitAsync();
+                    try
+                    {
+                        await WriteResponse(await DispatchGuarded(dispatcher, request));
+                    }
+                    finally
+                    {
+                        _slots.Release(ReadSlots);
+                    }
+                }
             }
 
+            if (inFlight.Count > 0)
+            {
+                try { await Task.WhenAll(inFlight); } catch { /* each response was already sent */ }
+            }
             Log.WriteLine("[INFO] stdin closed, bridge exiting");
             return 0;
         }
 
+        /// <summary>One read: take a slot, dispatch, answer. Never throws back into the loop.</summary>
+        private static async Task HandleConcurrently(RequestDispatcher dispatcher, BridgeRequest request)
+        {
+            await _slots.WaitAsync();
+            try
+            {
+                // Task.Run, not a bare await: every read handler returns
+                // Task.FromResult(...), so Dispatch runs to completion SYNCHRONOUSLY on
+                // whichever thread calls it. Awaiting it here left the work on the stdio
+                // loop thread and measured 1.06x against 1.04x for the serial build —
+                // the change did nothing until the work actually left this thread.
+                var response = await Task.Run(() => DispatchGuarded(dispatcher, request));
+                await WriteResponse(response);
+            }
+            finally
+            {
+                _slots.Release();
+            }
+        }
+
+        /// <summary>Dispatch, turning any escape into a response rather than a lost request.</summary>
+        private static async Task<BridgeResponse> DispatchGuarded(RequestDispatcher dispatcher, BridgeRequest request)
+        {
+            try
+            {
+                Log.WriteLine($"[DEBUG] → {request.Method} (id={request.Id})");
+                var response = await dispatcher.Dispatch(request);
+                Log.WriteLine($"[DEBUG] ← {request.Method} OK (id={request.Id})");
+                return response;
+            }
+            catch (Exception ex)
+            {
+                Log.WriteLine($"[ERROR] Unhandled: {ex.Message}\n{ex.StackTrace}");
+                return BridgeResponse.CreateError(request.Id, -32603, $"Internal error: {ex.Message}");
+            }
+        }
+
         private static async Task WriteResponse(BridgeResponse response)
         {
             var json = JsonSerializer.Serialize(response, JsonOptions.Default);
-            var stdout = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = true };
-            await stdout.WriteLineAsync(json);
-            await stdout.FlushAsync();
+            // Serialized, and on ONE cached writer: concurrent handlers each opening their
+            // own StreamWriter over the same handle is how a JSON-RPC stream gets interleaved.
+            await _stdoutLock.WaitAsync();
+            try
+            {
+                await _stdout.WriteLineAsync(json);
+                await _stdout.FlushAsync();
+            }
+            finally
+            {
+                _stdoutLock.Release();
+            }
         }
 
         /// <summary>

package/bridge/D365MetadataBridge/Protocol/RequestDispatcher.cs

@@ -813,6 +813,43 @@ namespace D365MetadataBridge.Protocol
             }
         }
 
+        /// <summary>
+        /// Methods that only READ metadata, and may therefore run concurrently with
+        /// each other.
+        ///
+        /// Measured on this VM: six reads issued together took 674 ms against 689 ms
+        /// issued one at a time — a 1.02x "speedup", because the stdio loop awaited each
+        /// Dispatch before reading the next line. Every fan-out the TS side performs
+        /// (get_object_info objects[], search queries[], prepare's five probes) was
+        /// therefore pipelining into a queue of one.
+        ///
+        /// The list is explicit and the DEFAULT IS FALSE: anything not named here —
+        /// including a method added later — keeps the old exclusive behaviour. A write
+        /// misfiled as a read would corrupt metadata; a read misfiled as a write is
+        /// merely as slow as it is today.
+        /// </summary>
+        private static readonly HashSet<string> ConcurrentSafeReads =
+            new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+            {
+                "ping", "getcapabilities", "getinfo", "getxrefschema",
+                // Typed readers
+                "readtable", "readclass", "readenum", "readedt", "readform", "readquery",
+                "readview", "readreport", "readdataentity", "readmenuitem",
+                "readsecurityprivilege", "readsecurityduty", "readsecurityrole",
+                "readtableextensions",
+                // Short aliases of the same readers
+                "table", "class", "enum", "edt", "form", "query", "view", "menu",
+                // Lookup / search
+                "searchobjects", "listobjects", "resolveobjectinfo", "getcompletionmembers",
+                "getmethodsource", "validateobject", "discoverformpatterns",
+                // Cross-reference queries
+                "findreferences", "findeventsubscribers", "findextensionclasses",
+                "findapiusagecallers", "samplexrefrows",
+            };
+
+        /// <summary>True when <paramref name="method"/> may run alongside other reads.</summary>
+        public static bool IsConcurrentSafeRead(string? method)
+            => !string.IsNullOrEmpty(method) && ConcurrentSafeReads.Contains(method!);
         private Task<BridgeResponse> HandleMetadata(BridgeRequest request, Func<object?> handler)
         {
             if (_metadataService == null)