d365fo-mcp 1.15.0 → 1.16.0

package/dist/bridge/bridgeAdapter.d.ts

@@ -22,7 +22,7 @@
  */
 import type { BridgeClient } from './bridgeClient.js';
 import type { BridgeAttempt } from './bridgeFailure.js';
-import type { BridgeSmartTableResult } from './bridgeTypes.js';
+import type { BridgeCompletionResult, BridgeSmartTableResult } from './bridgeTypes.js';
 /** Standard MCP tool response shape */
 export interface ToolResult {
     content: Array<{
@@ -538,7 +538,39 @@ export declare function tryBridgeSecurityArtifact(bridge: BridgeClient | undefin
 export declare function tryBridgeMenuItem(bridge: BridgeClient | undefined, name: string, itemType?: string): Promise<ToolResult | null>;
 export declare function tryBridgeTableExtensions(bridge: BridgeClient | undefined, baseTableName: string): Promise<ToolResult | null>;
 export declare function tryBridgeCompletion(bridge: BridgeClient | undefined, symbolName: string, prefix?: string, ancestors?: string[]): Promise<ToolResult | null>;
+/**
+ * One line of a member list — NAME first, always.
+ *
+ * This used to print the signature INSTEAD of the name whenever a signature
+ * existed, which made a member unidentifiable the moment the signature was
+ * wrong. It is sometimes wrong: the bridge's extractor hands back the line
+ * preceding the body when a macro sits between the doc block and the signature,
+ * so `SysQuery.range` was listed as `#ISOCountryRegionCodes`. Filtering runs on
+ * the NAME, so asking for prefix "range" returned "1 member" that appeared to be
+ * something else entirely — and a member list that renders a public API as
+ * another string argues the API does not exist. An eval run concluded exactly
+ * that and worked around a method that was there all along.
+ *
+ * The signature is still shown, as detail, and only when it plausibly belongs to
+ * this member. Fixing the extractor is a separate, C#-side change; this makes the
+ * output honest either way.
+ */
+declare function memberLine(m: {
+    name: string;
+    signature?: string;
+}): string;
+declare function formatCompletion(r: BridgeCompletionResult, prefix?: string): string;
 export declare function tryBridgeCocExtensions(bridge: BridgeClient | undefined, baseClassName: string, methodName?: string): Promise<ToolResult | null>;
 export declare function tryBridgeEventHandlers(bridge: BridgeClient | undefined, targetName: string, eventName?: string, handlerType?: string): Promise<ToolResult | null>;
 export declare function tryBridgeApiUsageCallers(bridge: BridgeClient | undefined, apiName: string, limit?: number): Promise<ToolResult | null>;
+/**
+ * Internals exposed for tests only. `formatCompletion` renders a member list,
+ * and a member list that cannot be trusted to name its members is worse than no
+ * list at all — see tests/bridge/completionMemberLine.test.ts.
+ */
+export declare const __testing: {
+    formatCompletion: typeof formatCompletion;
+    memberLine: typeof memberLine;
+};
+export {};
 //# sourceMappingURL=bridgeAdapter.d.ts.map

package/dist/bridge/bridgeAdapter.js

@@ -758,7 +758,23 @@ export async function tryBridgeSearch(bridge, query, objectType, maxResults = 50
         if (!sr)
             return null;
         // Splice in exact matches the bridge's truncated window missed (#15).
-        const bridgeHits = sr.results ?? [];
+        //
+        // …but first, honour the type filter the caller asked for, because the bridge
+        // does not always honour it. Its C#-side type map has no entry for every AOT
+        // kind — `report` is one — and an unmapped type runs the query UNFILTERED, so
+        // `search(type="report")` answered with tables and queries and looked
+        // authoritative doing it ("Cust" returned six tables). A report reached the
+        // caller only when the SQLite exact-name splice happened to carry one, which
+        // is why the failure looked intermittent rather than total.
+        //
+        // Only the BRIDGE's hits are filtered. The spliced exact and custom matches
+        // are deliberately allowed to differ in type — a `table-extension` is a
+        // wanted answer to a `type="table"` search for the table it extends — and
+        // filtering those too would delete that behaviour.
+        const rawBridgeHits = sr.results ?? [];
+        const bridgeHits = objectType && objectType !== 'all'
+            ? rawBridgeHits.filter(r => r.type === objectType)
+            : rawBridgeHits;
         const known = new Set(bridgeHits.map(r => `${r.name.toLowerCase()}\0${r.type}`));
         const spliced = [];
         for (const cand of opts?.exactMatches ?? []) {
@@ -2437,6 +2453,30 @@ export async function tryBridgeCompletion(bridge, symbolName, prefix, ancestors)
         return null;
     }
 }
+/**
+ * One line of a member list — NAME first, always.
+ *
+ * This used to print the signature INSTEAD of the name whenever a signature
+ * existed, which made a member unidentifiable the moment the signature was
+ * wrong. It is sometimes wrong: the bridge's extractor hands back the line
+ * preceding the body when a macro sits between the doc block and the signature,
+ * so `SysQuery.range` was listed as `#ISOCountryRegionCodes`. Filtering runs on
+ * the NAME, so asking for prefix "range" returned "1 member" that appeared to be
+ * something else entirely — and a member list that renders a public API as
+ * another string argues the API does not exist. An eval run concluded exactly
+ * that and worked around a method that was there all along.
+ *
+ * The signature is still shown, as detail, and only when it plausibly belongs to
+ * this member. Fixing the extractor is a separate, C#-side change; this makes the
+ * output honest either way.
+ */
+function memberLine(m) {
+    const sig = m.signature?.trim();
+    const belongs = sig && new RegExp(`\\b${m.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*\\(`, 'i').test(sig);
+    if (belongs)
+        return `\`${sig}\``;
+    return sig ? `**${m.name}** _(signature unavailable)_` : `**${m.name}**`;
+}
 function formatCompletion(r, prefix) {
     let members = r.members;
     if (prefix) {
@@ -2458,8 +2498,9 @@ function formatCompletion(r, prefix) {
         const inheritedCount = methodMembers.filter(m => m.inheritedFrom).length;
         out += `## Methods (${methodMembers.length})\n`;
         for (const m of methodMembers) {
-            const body = m.signature ? `\`${m.signature}\`` : m.name;
-            out += m.inheritedFrom ? `- ${body} _(inherited from ${m.inheritedFrom})_\n` : `- ${body}\n`;
+            out += m.inheritedFrom
+                ? `- ${memberLine(m)} _(inherited from ${m.inheritedFrom})_\n`
+                : `- ${memberLine(m)}\n`;
         }
         if (inheritedCount > 0) {
             out += `\n> ${inheritedCount} of these are inherited — callable on ${r.symbolName}, but ` +
@@ -2602,4 +2643,10 @@ function formatApiUsageCallers(r) {
     }
     return out;
 }
+/**
+ * Internals exposed for tests only. `formatCompletion` renders a member list,
+ * and a member list that cannot be trusted to name its members is worse than no
+ * list at all — see tests/bridge/completionMemberLine.test.ts.
+ */
+export const __testing = { formatCompletion, memberLine };
 //# sourceMappingURL=bridgeAdapter.js.map

package/dist/cli/commands/bpCatalog.js

@@ -18,7 +18,7 @@
  */
 import { createHash } from 'node:crypto';
 import { existsSync, readFileSync, readdirSync, renameSync, rmSync, statSync } from 'node:fs';
-import { basename, join, resolve } from 'node:path';
+import { join, resolve } from 'node:path';
 import { settingByPath } from '../../config/settings.js';
 import { findPackagesRoot } from '../../utils/packagesRoot.js';
 import { commandExists, runExe } from '../exec.js';
@@ -243,7 +243,10 @@ async function refreshCatalog(target, deps) {
             return;
         }
     }
-    p.log.step(`Refreshing BP moniker catalog (${target.label}, ${basename(source.packagesPath)})…`);
+    // No packages path in this line: the script's own report opens with the
+    // full path, and the tail of it ('PackagesLocalDirectory') identified
+    // nothing on a box with several installs.
+    p.log.step(`Refreshing BP moniker catalog (${target.label})…`);
     // Extract beside the real catalog, not over it. The script writes its output
     // in one go with no staging of its own, so pointing it straight at the live
     // file means a partial run destroys a good catalog before anything can judge

package/dist/knowledge/kernelEnums.js

@@ -50,6 +50,33 @@ const ENTRIES = [
             'Integer', 'List', 'RString', 'Real', 'Record', 'String', 'Time',
             'UserType', 'UtcDateTime', 'VarArg', 'VarString', 'Void',
         ] },
+    // What Box::yesNo/confirm/okCancel answer with. Found by the knowledge audit,
+    // which reported "DialogButton does not exist in the symbol index" for a topic
+    // whose call shape had already compiled in an xppc probe — the same
+    // absent-from-the-AOT-is-not-absent trap this module exists for. Values are the
+    // ones shipped code actually uses, counted over 30,000 AxClass/AxForm files:
+    // Yes 602, No 561, Cancel 154, Ok 129, YesToAll 7, NoToAll 6.
+    { name: 'DialogButton', values: ['Cancel', 'No', 'NoToAll', 'Ok', 'Yes', 'YesToAll'] },
+    // Added 2026-08-31 after an eval run tripped over AccessType and MenuItemType:
+    // validate_code(mode="references") called both hard ERRORS on code that
+    // compiles, and with GROUNDING_ENFORCE on it would have REFUSED the write —
+    // the exact failure this module was created to prevent. That both were absent
+    // was the signal that the list had never been derived from anything, so it is
+    // now checked by `npm run oracle:kernel-enums`, which finds every `Name::Value`
+    // in shipped X++ with no AOT element behind it. Values below are what the
+    // product itself writes, counted by that audit, not recalled.
+    { name: 'MenuItemType', values: ['Action', 'Display', 'Output'] },
+    { name: 'AccessType', values: ['Add', 'Correction', 'Delete', 'Edit', 'NoAccess', 'View'] },
+    { name: 'AccessRight', values: ['Add', 'Correction', 'Delete', 'Edit', 'NoAccess', 'View'] },
+    { name: 'SortOrder', values: ['Ascending', 'Descending'] },
+    // QueryBuildDataSource.joinMode(). Reported by a second eval run, through the
+    // static-member rule rather than the declared-type one — the two rules did not
+    // share the kernel-name exemption, so the same fact was a warning in one place
+    // and an error in the other.
+    { name: 'JoinMode', values: ['ExistsJoin', 'InnerJoin', 'NoExistsJoin', 'OuterJoin'] },
+    // The argument to an `unchecked(...)` block. Only these two members exist —
+    // DBSchemaDrift and Deadlock read plausibly and are not real (xppc-verified).
+    { name: 'Uncheck', values: ['TableSecurityPermission', 'XDS'] },
     { name: 'TableScope', values: ['CurrentTableOnly', 'IncludeBaseTables', 'IncludeDerivedTables'] },
     { name: 'ConcurrencyModel', values: ['Auto', 'Optimistic', 'Pessimistic'] },
     { name: 'StatementType', values: ['Delete', 'Insert', 'Select', 'Update'] },

package/dist/scripts/buildIndexWorker.js

@@ -0,0 +1,149 @@
+// src/metadata/buildIndexWorker.ts
+import { parentPort, workerData } from "node:worker_threads";
+
+// src/database/nodeSqlite.ts
+import { createRequire } from "node:module";
+function load() {
+  const original = process.emitWarning.bind(process);
+  process.emitWarning = ((warning, ...rest) => {
+    const message = typeof warning === "string" ? warning : warning?.message ?? "";
+    const first = rest[0];
+    const type = typeof first === "string" ? first : first?.type ?? "";
+    if (type === "ExperimentalWarning" && /\bSQLite\b/.test(message)) return;
+    original(warning, ...rest);
+  });
+  try {
+    return createRequire(import.meta.url)("node:sqlite");
+  } finally {
+    process.emitWarning = original;
+  }
+}
+var { DatabaseSync: DatabaseSyncClass } = load();
+
+// src/database/sqlite.ts
+var OBJECT_PROTO = Object.prototype;
+function reproto(row) {
+  if (row !== null && typeof row === "object") Object.setPrototypeOf(row, OBJECT_PROTO);
+  return row;
+}
+var Statement = class {
+  constructor(stmt) {
+    this.stmt = stmt;
+  }
+  stmt;
+  run(...params) {
+    return this.stmt.run(...params);
+  }
+  get(...params) {
+    const row = this.stmt.get(...params);
+    return row === void 0 ? void 0 : reproto(row);
+  }
+  all(...params) {
+    const rows = this.stmt.all(...params);
+    for (let i = 0; i < rows.length; i++) reproto(rows[i]);
+    return rows;
+  }
+  *iterate(...params) {
+    for (const row of this.stmt.iterate(...params)) {
+      yield reproto(row);
+    }
+  }
+};
+var Database = class {
+  handle;
+  /**
+   * Depth of nested transaction() calls. better-sqlite3 nests via SAVEPOINT;
+   * plain BEGIN would throw "cannot start a transaction within a transaction".
+   */
+  txDepth = 0;
+  name;
+  constructor(filename, options = {}) {
+    this.name = filename;
+    this.handle = new DatabaseSyncClass(filename, {
+      readOnly: options.readonly === true,
+      // better-sqlite3 leaves foreign_keys at SQLite's OFF default; node:sqlite
+      // turns them on. Our schema has FK columns that are intentionally not
+      // enforced (rows are inserted out of order during a build).
+      enableForeignKeyConstraints: false
+    });
+  }
+  get open() {
+    return this.handle.isOpen;
+  }
+  /**
+   * `PRAGMA <source>`. With `{ simple: true }` returns the first column of the
+   * first row (better-sqlite3's shorthand for scalar pragmas such as
+   * journal_mode); otherwise the full row array. Assignment pragmas
+   * ("cache_size = -64000") return an empty array.
+   */
+  pragma(source, options) {
+    let rows;
+    try {
+      rows = this.handle.prepare(`PRAGMA ${source}`).all();
+    } catch {
+      this.handle.exec(`PRAGMA ${source}`);
+      rows = [];
+    }
+    if (options?.simple) {
+      const first = rows[0];
+      return first === void 0 ? void 0 : Object.values(first)[0];
+    }
+    for (const row of rows) reproto(row);
+    return rows;
+  }
+  prepare(sql2) {
+    return new Statement(this.handle.prepare(sql2));
+  }
+  exec(sql2) {
+    this.handle.exec(sql2);
+  }
+  /**
+   * Wraps `fn` so that calling it runs inside a transaction, rolling back if it
+   * throws. Matches better-sqlite3's `db.transaction(fn)`: arguments passed to
+   * the returned function are forwarded to `fn`, and the return value is
+   * `fn`'s.
+   */
+  transaction(fn) {
+    return (...args) => {
+      const depth = this.txDepth++;
+      const nested = depth > 0;
+      const savepoint = `d365fo_sp_${depth}`;
+      this.handle.exec(nested ? `SAVEPOINT ${savepoint}` : "BEGIN");
+      try {
+        const result = fn(...args);
+        this.handle.exec(nested ? `RELEASE ${savepoint}` : "COMMIT");
+        return result;
+      } catch (err) {
+        try {
+          this.handle.exec(
+            nested ? `ROLLBACK TO ${savepoint}; RELEASE ${savepoint}` : "ROLLBACK"
+          );
+        } catch {
+        }
+        throw err;
+      } finally {
+        this.txDepth--;
+      }
+    };
+  }
+  close() {
+    if (this.handle.isOpen) this.handle.close();
+  }
+};
+var sqlite_default = Database;
+
+// src/metadata/buildIndexWorker.ts
+var { dbPath, sql } = workerData;
+try {
+  const db = new sqlite_default(dbPath);
+  try {
+    db.pragma("busy_timeout = 120000");
+    const started = Date.now();
+    db.exec(sql);
+    parentPort.postMessage({ ok: true, elapsedMs: Date.now() - started });
+  } finally {
+    db.close();
+  }
+} catch (e) {
+  parentPort.postMessage({ ok: false, error: String(e) });
+}

package/dist/scripts/indexWarmupWorker.js

@@ -0,0 +1,201 @@
+// src/metadata/indexWarmupWorker.ts
+import { parentPort, workerData } from "node:worker_threads";
+
+// src/database/nodeSqlite.ts
+import { createRequire } from "node:module";
+function load() {
+  const original = process.emitWarning.bind(process);
+  process.emitWarning = ((warning, ...rest) => {
+    const message = typeof warning === "string" ? warning : warning?.message ?? "";
+    const first = rest[0];
+    const type = typeof first === "string" ? first : first?.type ?? "";
+    if (type === "ExperimentalWarning" && /\bSQLite\b/.test(message)) return;
+    original(warning, ...rest);
+  });
+  try {
+    return createRequire(import.meta.url)("node:sqlite");
+  } finally {
+    process.emitWarning = original;
+  }
+}
+var { DatabaseSync: DatabaseSyncClass } = load();
+
+// src/database/sqlite.ts
+var OBJECT_PROTO = Object.prototype;
+function reproto(row) {
+  if (row !== null && typeof row === "object") Object.setPrototypeOf(row, OBJECT_PROTO);
+  return row;
+}
+var Statement = class {
+  constructor(stmt) {
+    this.stmt = stmt;
+  }
+  stmt;
+  run(...params) {
+    return this.stmt.run(...params);
+  }
+  get(...params) {
+    const row = this.stmt.get(...params);
+    return row === void 0 ? void 0 : reproto(row);
+  }
+  all(...params) {
+    const rows = this.stmt.all(...params);
+    for (let i = 0; i < rows.length; i++) reproto(rows[i]);
+    return rows;
+  }
+  *iterate(...params) {
+    for (const row of this.stmt.iterate(...params)) {
+      yield reproto(row);
+    }
+  }
+};
+var Database = class {
+  handle;
+  /**
+   * Depth of nested transaction() calls. better-sqlite3 nests via SAVEPOINT;
+   * plain BEGIN would throw "cannot start a transaction within a transaction".
+   */
+  txDepth = 0;
+  name;
+  constructor(filename, options = {}) {
+    this.name = filename;
+    this.handle = new DatabaseSyncClass(filename, {
+      readOnly: options.readonly === true,
+      // better-sqlite3 leaves foreign_keys at SQLite's OFF default; node:sqlite
+      // turns them on. Our schema has FK columns that are intentionally not
+      // enforced (rows are inserted out of order during a build).
+      enableForeignKeyConstraints: false
+    });
+  }
+  get open() {
+    return this.handle.isOpen;
+  }
+  /**
+   * `PRAGMA <source>`. With `{ simple: true }` returns the first column of the
+   * first row (better-sqlite3's shorthand for scalar pragmas such as
+   * journal_mode); otherwise the full row array. Assignment pragmas
+   * ("cache_size = -64000") return an empty array.
+   */
+  pragma(source, options) {
+    let rows;
+    try {
+      rows = this.handle.prepare(`PRAGMA ${source}`).all();
+    } catch {
+      this.handle.exec(`PRAGMA ${source}`);
+      rows = [];
+    }
+    if (options?.simple) {
+      const first = rows[0];
+      return first === void 0 ? void 0 : Object.values(first)[0];
+    }
+    for (const row of rows) reproto(row);
+    return rows;
+  }
+  prepare(sql) {
+    return new Statement(this.handle.prepare(sql));
+  }
+  exec(sql) {
+    this.handle.exec(sql);
+  }
+  /**
+   * Wraps `fn` so that calling it runs inside a transaction, rolling back if it
+   * throws. Matches better-sqlite3's `db.transaction(fn)`: arguments passed to
+   * the returned function are forwarded to `fn`, and the return value is
+   * `fn`'s.
+   */
+  transaction(fn) {
+    return (...args) => {
+      const depth = this.txDepth++;
+      const nested = depth > 0;
+      const savepoint = `d365fo_sp_${depth}`;
+      this.handle.exec(nested ? `SAVEPOINT ${savepoint}` : "BEGIN");
+      try {
+        const result = fn(...args);
+        this.handle.exec(nested ? `RELEASE ${savepoint}` : "COMMIT");
+        return result;
+      } catch (err) {
+        try {
+          this.handle.exec(
+            nested ? `ROLLBACK TO ${savepoint}; RELEASE ${savepoint}` : "ROLLBACK"
+          );
+        } catch {
+        }
+        throw err;
+      } finally {
+        this.txDepth--;
+      }
+    };
+  }
+  close() {
+    if (this.handle.isOpen) this.handle.close();
+  }
+};
+var sqlite_default = Database;
+
+// src/metadata/indexWarmupWorker.ts
+var WARMUP_STEPS = [
+  {
+    name: "symbols.idx_symbols_name",
+    db: "symbols",
+    sql: `SELECT COUNT(*) AS n FROM symbols INDEXED BY idx_symbols_name WHERE name > ''`
+  },
+  {
+    name: "labels join label_files",
+    db: "labels",
+    sql: `SELECT COUNT(*) AS n FROM labels l JOIN label_files lf ON lf.id = l.file_path_id
+          WHERE LOWER(l.language) = 'en-us'`
+  },
+  {
+    name: "symbols.idx_type_name",
+    db: "symbols",
+    sql: `SELECT COUNT(*) AS n FROM symbols INDEXED BY idx_type_name WHERE type > ''`
+  },
+  {
+    name: "labels_fts",
+    db: "labels",
+    sql: `SELECT COUNT(*) AS n FROM labels_fts WHERE labels_fts MATCH 'cannot OR value OR not'`
+  },
+  {
+    name: "symbols_fts",
+    db: "symbols",
+    sql: `SELECT COUNT(*) AS n FROM symbols_fts WHERE symbols_fts MATCH '"table"*'`
+  }
+];
+if (parentPort) {
+  const { dbPath, labelsDbPath, budgetMs } = workerData;
+  const started = Date.now();
+  const open = (p) => {
+    const db = new sqlite_default(p, { readonly: true });
+    db.pragma("busy_timeout = 5000");
+    return db;
+  };
+  let symbols = null;
+  let labels = null;
+  try {
+    for (const step of WARMUP_STEPS) {
+      if (Date.now() - started >= budgetMs) break;
+      try {
+        if (step.db === "symbols") symbols ??= open(dbPath);
+        else labels ??= open(labelsDbPath);
+        const db = step.db === "symbols" ? symbols : labels;
+        const t0 = Date.now();
+        const row = db.prepare(step.sql).get();
+        parentPort.postMessage({
+          type: "step",
+          name: step.name,
+          ms: Date.now() - t0,
+          rows: row?.n ?? 0
+        });
+      } catch (e) {
+        parentPort.postMessage({ type: "error", name: step.name, error: String(e) });
+      }
+    }
+    parentPort.postMessage({ type: "done", totalMs: Date.now() - started });
+  } finally {
+    symbols?.close();
+    labels?.close();
+  }
+}
+export {
+  WARMUP_STEPS
+};

package/dist/server/toolSchemas/prepare.js

@@ -29,7 +29,7 @@ export const prepareTool = {
             },
             objectName: {
                 type: 'string',
-                description: '[change] Name of the object to extend/modify (e.g. "CustTable"). [create] Proposed BASE name WITHOUT model prefix (same value you would pass to d365fo_file create).',
+                description: '[change] Name of the object to extend/modify (e.g. "CustTable"). [create] Proposed BASE name WITHOUT model prefix.',
             },
             objectType: {
                 type: 'string',
@@ -39,8 +39,14 @@ export const prepareTool = {
                     'menu-item-output', 'menu', 'security-privilege', 'security-duty', 'security-role',
                     'business-event', 'tile', 'kpi', 'service', 'service-group',
                     'macro', 'configuration-key', 'security-policy', 'aggregate-measurement', 'license-code',
+                    // Extension artefacts, published here as well as in prepareCreate's zod
+                    // schema. #983 added them to the zod schema only — the handler accepted
+                    // them and the tool list did not offer them, so an agent still could not
+                    // pick one. That is the very disagreement #983 was filed about, one level
+                    // up. tests/server/toolSchemaAgreement.test.ts now pins the two together.
+                    'table-extension', 'class-extension', 'form-extension', 'enum-extension', 'edt-extension',
                 ],
-                description: '[change] D365FO object type — auto-detected when omitted. [create] REQUIRED — type of the new object.',
+                description: '[change] type — auto-detected when omitted. [create] REQUIRED; an extension is Base.Suffix.',
             },
             methodName: {
                 type: 'string',
@@ -51,7 +57,7 @@ export const prepareTool = {
                 // Comma-separated rather than a second array parameter: a table change
                 // is normally add-field AND add-index AND add-field-to-field-group, and
                 // one clause here is far cheaper per session than another schema block.
-                description: '[change] The modify operation(s) you intend to run — comma-separated for several ("add-field,add-index"). Their full parameter contracts come back in THIS response, so no separate op-spec call. Defaults to add-method when methodName is given.',
+                description: '[change] The modify operation(s) you intend to run — comma-separated for several ("add-field,add-index"). Their full parameter contracts come back in THIS response. Defaults to add-method when methodName is given.',
             },
             proposedName: {
                 type: 'string',

package/dist/server/toolSchemas/validateCode.js

@@ -23,9 +23,9 @@ export const validateCodeTool = {
             },
             codeType: {
                 type: 'string',
-                enum: ['xpp', 'xml-table', 'xml-any', 'xml-report'],
+                enum: ['xpp', 'xml-table', 'xml-form', 'xml-any', 'xml-report'],
                 default: 'xpp',
-                description: '[syntax] "xpp" X++ source (default), "xml-table" AxTable, "xml-report" AxReport, "xml-any" other XML.',
+                description: '[syntax] "xpp" X++ (default), "xml-table" AxTable, "xml-form" AxForm(+Extension), "xml-report" AxReport, "xml-any" other.',
             },
             context: {
                 type: 'string',

package/dist/tools/analysis/validateXpp.d.ts

@@ -64,6 +64,7 @@ export declare const validateXppArgsSchema: z.ZodObject<{
     code: z.ZodString;
     codeType: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
         "xml-any": "xml-any";
+        "xml-form": "xml-form";
         "xml-report": "xml-report";
         "xml-table": "xml-table";
         xpp: "xpp";
@@ -100,7 +101,7 @@ export interface PropertyStatsProvider {
         count: number;
     }>;
 }
-export declare function runRules(code: string, codeType: 'xpp' | 'xml-table' | 'xml-any' | 'xml-report', stats?: PropertyStatsProvider): ValidationViolation[];
+export declare function runRules(code: string, codeType: 'xpp' | 'xml-table' | 'xml-form' | 'xml-any' | 'xml-report', stats?: PropertyStatsProvider): ValidationViolation[];
 export declare function validateXppTool(request: any, serverContext?: {
     symbolIndex?: PropertyStatsProvider;
 }): Promise<any>;