d365fo-mcp 1.0.0

package/dist/prompts/codeReview.js

@@ -0,0 +1,619 @@
+/**
+ * MCP Prompt: X++ Code Review
+ * Provides code review prompts for X++ best practices
+ */
+import { GetPromptRequestSchema, ListPromptsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+import { getSystemInstructionsPromptDefinition, handleSystemInstructionsPrompt } from './systemInstructions.js';
+const CodeReviewArgsSchema = z.object({
+    code: z.string().describe('X++ code to review'),
+});
+const ExplainClassArgsSchema = z.object({
+    className: z.string().describe('Name of the class to explain'),
+});
+export function registerCodeReviewPrompt(server, context) {
+    const { symbolIndex, parser } = context;
+    server.setRequestHandler(ListPromptsRequestSchema, async () => {
+        return {
+            prompts: [
+                getSystemInstructionsPromptDefinition(),
+                {
+                    name: 'xpp_create_file',
+                    description: '🔥 USE THIS WHEN CREATING D365FO FILES: Mandatory workflow for creating D365FO classes, tables, forms, enums. ALWAYS use d365fo_file(action="create") tool FIRST.',
+                    arguments: [],
+                },
+                {
+                    name: 'xpp_code_review',
+                    description: 'Review X++ code for best practices and potential issues',
+                    arguments: [
+                        {
+                            name: 'code',
+                            description: 'X++ code to review',
+                            required: true,
+                        },
+                    ],
+                },
+                {
+                    name: 'xpp_explain_class',
+                    description: 'Get a detailed explanation of an X++ class',
+                    arguments: [
+                        {
+                            name: 'className',
+                            description: 'Name of the class to explain',
+                            required: true,
+                        },
+                    ],
+                },
+                {
+                    name: 'xpp_extension_guide',
+                    description: 'Complete guide for CoC (Chain of Command) extensions and event handlers in D365FO',
+                    arguments: [],
+                },
+                {
+                    name: 'xpp_security_guide',
+                    description: 'D365FO security model creation guide: privilege, duty, role, and menu item workflow',
+                    arguments: [
+                        {
+                            name: 'featureName',
+                            description: 'Feature or object name for context (optional)',
+                            required: false,
+                        },
+                    ],
+                },
+                {
+                    name: 'xpp_sysoperation_guide',
+                    description: 'SysOperation framework reference: DataContract + Controller + Service pattern for batch operations',
+                    arguments: [
+                        {
+                            name: 'operationDescription',
+                            description: 'Description of the operation to implement (optional)',
+                            required: false,
+                        },
+                    ],
+                },
+                {
+                    name: 'xpp_data_entity_guide',
+                    description: 'Data entity development guide: OData, DMF, staging tables, computed columns',
+                    arguments: [
+                        {
+                            name: 'entityCategory',
+                            description: 'Entity category: parameter, reference, master, document, or transaction (optional)',
+                            required: false,
+                        },
+                    ],
+                },
+            ],
+        };
+    });
+    // Handle prompt requests
+    server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+        const promptName = request.params.name;
+        // Handle system instructions prompt
+        if (promptName === 'xpp_system_instructions') {
+            return handleSystemInstructionsPrompt();
+        }
+        // Handle file creation prompt
+        if (promptName === 'xpp_create_file') {
+            return {
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `🔥 CRITICAL: File Creation Workflow for D365FO
+
+When user asks to CREATE any D365FO object (class, table, form, enum, query, view):
+
+MANDATORY STEPS (NO EXCEPTIONS):
+
+1. ALWAYS call d365fo_file(action="create") FIRST:
+   - objectType: class/table/form/enum/query/view
+   - objectName: from user request
+   - modelName: auto-detected from .mcp.json (NEVER ask user)
+   - addToProject: true
+   - sourceCode: generated X++ code
+
+2. IF d365fo_file(action="create") fails:
+   THEN STOP and report the error to the user.
+   NEVER fall back to create_file or PowerShell.
+
+FORBIDDEN:
+❌ NEVER use d365fo_file(action="generate") + create_file as a fallback
+❌ NEVER use create_file directly for D365FO objects
+❌ NEVER skip d365fo_file(action="create")
+
+Example:
+User: "Create class MyHelper"
+You: d365fo_file({
+  action: "create",
+  objectType: "class",
+  objectName: "MyHelper", 
+  modelName: "CustomCore",
+  addToProject: true,
+  sourceCode: "..."
+})`,
+                        },
+                    },
+                ],
+            };
+        }
+        if (promptName === 'xpp_code_review') {
+            const args = CodeReviewArgsSchema.parse(request.params.arguments || {});
+            return {
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `Please review the following X++ code for:
+1. Best practices compliance
+2. Performance considerations
+3. Security issues
+4. Transaction handling (ttsbegin/ttscommit)
+5. Error handling patterns
+6. Naming conventions
+7. Code structure and organization
+8. Deprecated API usage (today() → DateTimeUtil::getToday, RunBase → SysOperation)
+9. Hardcoded strings — must use label references @ModelName:LabelId
+10. Nested data access loops (while select inside while select → use joins)
+
+Code to review:
+\`\`\`xpp
+${args.code}
+\`\`\``,
+                        },
+                    },
+                ],
+            };
+        }
+        if (promptName === 'xpp_explain_class') {
+            const args = ExplainClassArgsSchema.parse(request.params.arguments || {});
+            const classSymbol = symbolIndex.getSymbolByName(args.className, 'class');
+            let classSource = 'Class not found in index';
+            if (classSymbol) {
+                try {
+                    const classInfo = await parser.parseClassFile(classSymbol.filePath);
+                    if (classInfo.success && classInfo.data) {
+                        classSource = [
+                            classInfo.data.declaration,
+                            ...classInfo.data.methods.map((m) => m.source),
+                        ].join('\n\n');
+                    }
+                }
+                catch (error) {
+                    classSource = `Error loading class: ${error}`;
+                }
+            }
+            return {
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `Please explain the following X++ class "${args.className}", including:
+1. Purpose and responsibilities
+2. How it fits in D365 F&O architecture
+3. Key methods and their functionality
+4. Usage patterns and examples
+5. Dependencies and relationships
+
+Class source:
+\`\`\`xpp
+${classSource}
+\`\`\``,
+                        },
+                    },
+                ],
+            };
+        }
+        if (promptName === 'xpp_extension_guide') {
+            return {
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `# D365FO Extension Guide: CoC and Event Handlers
+
+## Chain of Command (CoC) Extensions
+
+Use CoC when you need to wrap or augment an existing method's logic.
+
+### Prerequisites
+1. Call \`get_method(include="signature")\` to get exact parameter types and return type
+2. Call \`extension_info(mode="coc")\` to check if the method is already wrapped
+3. Call \`extension_info(mode="points")\` to verify the method is CoC-eligible (not \`final\` / \`[Hookable(false)]\`)
+
+### Class rule
+\`\`\`xpp
+[ExtensionOf(classStr(SalesFormLetter))]
+final class SalesFormLetterWHS_Extension
+{
+    public void run()
+    {
+        // Pre-processing (optional)
+        next run();     // ALWAYS call next — never skip it
+        // Post-processing (optional)
+    }
+}
+\`\`\`
+
+### Naming
+- Class extensions:  \`{Base}{Prefix}_Extension\`   e.g. \`SalesFormLetterWHS_Extension\`
+- Table/form/enum:   \`{Base}.{Prefix}Extension\`    e.g. \`SalesTable.WHSExtension\` (AOT name)
+
+### Rules
+- ALWAYS call \`next methodName(...)\` with ALL original parameters preserved
+- Place \`next\` at the START for pre-processing, END for post-processing, or BOTH for wrapping
+- Use \`generate_object(mode="pattern") pattern='table-extension'\` or \`'form-handler'\` for the skeleton
+
+---
+
+## Event Handler Pattern (SubscribesTo)
+
+Use event handlers for loosely-coupled reactions to table/class/form events.
+
+### When to use
+- Need to react to standard table events (onInserted, onUpdated, onDeleted, onValidatedWrite …)
+- Avoid tight coupling — no need to wrap a method
+
+### Workflow
+1. Call \`extension_info(mode="points")\` with the target class/table to see available events
+2. Call \`extension_info(mode="events")\` to check if the event already has handlers (avoid duplicates)
+3. Use \`generate_object(mode="pattern") pattern='event-handler' name='{BaseName}EventHandler' baseName='{BaseName}'\`
+
+### Template
+\`\`\`xpp
+public final class CustTableEventHandler
+{
+    [DataEventHandler(tableStr(CustTable), DataEventType::Inserted)]
+    public static void CustTable_onInserted(Common _sender, DataEventArgs _e)
+    {
+        CustTable record = _sender;
+        // Logic here
+    }
+}
+\`\`\`
+
+### Rules
+- Handler methods MUST be \`static public void\`
+- Standard table data events (onInserted, onUpdated, onDeleted, onValidatedWrite, etc.) → use \`[DataEventHandler(tableStr(...), DataEventType::...)]\`
+- Custom delegates only → use \`[SubscribesTo(tableStr(...), delegateStr(...))]\`
+- Table events → use \`tableStr()\`; class events → \`classStr()\`; form events → \`formStr()\`
+
+---
+
+## When to use CoC vs Event Handlers
+
+| Scenario | Use |
+|---|---|
+| Modify return value of a method | CoC |
+| Add logic before/after a specific method | CoC |
+| React to a data change across the codebase | Event Handler |
+| Avoid dependency on a specific class | Event Handler |
+| Method is \`final\` or \`[Hookable(false)]\` | Neither — use delegate or different approach |
+`,
+                        },
+                    },
+                ],
+            };
+        }
+        if (promptName === 'xpp_security_guide') {
+            const featureName = request.params.arguments?.featureName || '';
+            return {
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `# D365FO Security Model Creation Guide${featureName ? ` — ${featureName}` : ''}
+
+## Security Hierarchy
+\`\`\`
+Role (e.g. AccountsReceivableClerk)
+  └── Duty  (e.g. CustTableMaintain)
+        └── Privilege  (e.g. CustTableView, CustTableFullControl)
+              └── Entry Point (e.g. MenuItemDisplay: CustTable)
+\`\`\`
+
+## Step-by-Step Workflow
+
+### 1. Check existing coverage first
+\`\`\`
+security_info(mode="coverage", objectName: "CustTable", objectType: "form")
+\`\`\`
+
+### 2. Create menu item XML
+\`\`\`
+generate_object(mode="pattern", pattern: "menu-item", name: "MyFeature", menuItemType: "display", targetObject: "MyFeatureForm")
+\`\`\`
+
+### 3. Create privilege XML (always create BOTH View + Maintain)
+\`\`\`
+generate_object(mode="pattern", pattern: "security-privilege", name: "MyFeature", targetObject: "MyFeature")
+\`\`\`
+
+This generates:
+- **MyFeatureView** — Read access (for inquiry roles)
+- **MyFeatureMaintain** — Update/Create/Delete access (for operational roles)
+
+### 4. Create duty referencing both privileges
+\`\`\`xml
+<AxSecurityDuty>
+  <Name>MyFeatureMaintainDuty</Name>
+  <Label>@LabelId</Label>
+  <Privileges>
+    <AxSecurityRolePermissionSet><Name>MyFeatureView</Name></AxSecurityRolePermissionSet>
+    <AxSecurityRolePermissionSet><Name>MyFeatureMaintain</Name></AxSecurityRolePermissionSet>
+  </Privileges>
+</AxSecurityDuty>
+\`\`\`
+
+### 5. Assign duty to an existing role
+\`\`\`
+security_info(mode="artifact", name: "AccountsReceivableClerk", artifactType: "role")
+\`\`\`
+Then add the duty to that role's XML.
+
+## Naming Conventions
+
+| Object | Pattern | Example |
+|---|---|---|
+| Privilege (view) | \`{Object}View\` | \`CustTableView\` |
+| Privilege (maintain) | \`{Object}Maintain\` | \`CustTableMaintain\` |
+| Duty | \`{Object}{Action}Duty\` | \`CustTableMaintainDuty\` |
+| Menu item | Match form/class name | \`CustTable\` |
+
+## Segregation of Duties
+- View and Maintain privileges should be in SEPARATE duties when SoD rules apply
+- Never grant Delete access in the same privilege as Create without business justification
+- Use \`security_info(mode="artifact")\` to verify existing duty assignments before creating new ones
+`,
+                        },
+                    },
+                ],
+            };
+        }
+        if (promptName === 'xpp_sysoperation_guide') {
+            const operationDescription = request.params.arguments?.operationDescription || '';
+            return {
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `# D365FO SysOperation Framework Guide${operationDescription ? `\nOperation: ${operationDescription}` : ''}
+
+## Overview
+SysOperation is the **modern replacement for RunBaseBatch**. Always use SysOperation for new batch/dialog operations.
+Generate the full scaffold with: \`generate_object(mode="pattern", pattern: "sysoperation", name: "MyOperation")\`
+
+## Three Classes
+
+### 1. DataContract — stores parameters
+\`\`\`xpp
+[DataContractAttribute]
+public final class MyOperationDataContract
+{
+    TransDate   transDate;
+
+    [DataMemberAttribute('TransDate'),
+     SysOperationLabelAttribute(literalStr("@SYS24562"))]
+    public TransDate parmTransDate(TransDate _transDate = transDate)
+    {
+        transDate = _transDate;
+        return transDate;
+    }
+}
+\`\`\`
+
+**Rules:**
+- Each parameter = one field + one \`parmXxx\` method
+- \`[DataMemberAttribute('FieldName')]\` maps to dialog/DMF field name
+- NEVER use \`pack()\`/\`unpack()\` — that's the old RunBase pattern
+- For grouped parameters, use sub-contracts: \`[DataMemberAttribute] public SubContract parmSub(...)\`
+
+### 2. Controller — entry point and execution mode
+\`\`\`xpp
+class MyOperationController extends SysOperationServiceController
+{
+    protected ClassDescription defaultCaption()
+    {
+        return "@SYS112020";
+    }
+
+    public static void main(Args _args)
+    {
+        MyOperationController controller = new MyOperationController(
+            classStr(MyOperationService),
+            methodStr(MyOperationService, processMyOperation),
+            SysOperationExecutionMode::Synchronous);  // or Asynchronous / ScheduledBatch
+        controller.startOperation();
+    }
+}
+\`\`\`
+
+**Execution modes:**
+| Mode | Use case |
+|---|---|
+| \`Synchronous\` | Fast operations, immediate result needed |
+| \`Asynchronous\` | Long-running but user waits |
+| \`ScheduledBatch\` | Background batch processing |
+
+### 3. Service — business logic
+\`\`\`xpp
+class MyOperationService extends SysOperationServiceBase
+{
+    [SysEntryPointAttribute(true)]   // required for security
+    public void processMyOperation(MyOperationDataContract _contract)
+    {
+        TransDate transDate = _contract.parmTransDate();
+
+        ttsbegin;
+        // Business logic here
+        ttscommit;
+    }
+}
+\`\`\`
+
+**Rules:**
+- Service method MUST be marked \`[SysEntryPointAttribute(true)]\`
+- Use \`ttsbegin/ttscommit\` for all database writes
+- Never catch exceptions inside tts block — let the framework roll back
+
+## UIBuilder (Advanced Dialog Customization)
+
+Use \`SysOperationAutomaticUIBuilder\` to customize the dialog beyond DataContract defaults:
+
+\`\`\`xpp
+[DataContractAttribute,
+ SysOperationContractProcessingAttribute(classStr(MyOperationUIBuilder))]
+public final class MyOperationDataContract
+{
+    // ... parm methods as above
+}
+
+class MyOperationUIBuilder extends SysOperationAutomaticUIBuilder
+{
+    protected void postBuild()
+    {
+        super();
+        // Access and customize dialog controls after they're auto-built
+        DialogField dateField = this.bindInfo().getDialogField(
+            this.dataContractObject(), methodStr(MyOperationDataContract, parmTransDate));
+        dateField.lookupButton(FormLookupButton::Always);
+    }
+
+    protected void postRun()
+    {
+        super();
+        // Register event handlers for dialog controls (e.g. lookup, modified)
+    }
+}
+\`\`\`
+
+## SysOperation vs RunBase Decision
+
+| Feature | SysOperation ✅ | RunBase ❌ (deprecated) |
+|---|---|---|
+| Serialization | Automatic via DataContract | Manual pack()/unpack() |
+| Dialog | Auto-generated from parm methods | Manual dialogFields |
+| Batch support | Built-in | Manual canGoBatch() |
+| Security | \`[SysEntryPointAttribute]\` | Manual authorization |
+| Extensibility | CoC on service/controller | Hard to extend |
+| State management | Framework-managed | Manual container |
+
+## Error Handling
+\`\`\`xpp
+try
+{
+    ttsbegin;
+    // logic
+    ttscommit;
+}
+catch (Exception::Error)
+{
+    // tts is automatically rolled back
+    error("@SYS319855");
+}
+\`\`\`
+
+## Testing
+\`\`\`xpp
+// Programmatic invocation (unit tests / runnable class)
+MyOperationController::main(new Args());
+\`\`\`
+`,
+                        },
+                    },
+                ],
+            };
+        }
+        if (promptName === 'xpp_data_entity_guide') {
+            const entityCategory = request.params.arguments?.entityCategory || '';
+            return {
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `# D365FO Data Entity Development Guide${entityCategory ? `\nCategory: ${entityCategory}` : ''}
+
+## Entity Categories
+
+| Category | Purpose | Example |
+|---|---|---|
+| \`parameter\` | System/module configuration | LedgerParameters |
+| \`reference\` | Lookup/master data without transactions | Currency |
+| \`master\` | Core business objects | Customer, Vendor |
+| \`document\` | Business transactions with header/lines | SalesOrder |
+| \`transaction\` | Posted/immutable records | GeneralJournalEntry |
+
+## Checking Existing Entities
+\`\`\`
+get_object_info(objectType: "data-entity", name: "CustCustomerV3Entity")
+\`\`\`
+
+## Structure Pattern
+\`\`\`xpp
+[DataEntityViewAttribute,
+ SysOperationContractAttribute,
+ PublicCollectionNameAttribute('Customers'),
+ PublicEntityNameAttribute('Customer')]
+public class CustCustomerV3Entity extends common
+{
+    // Root table datasource fields mapped directly
+    // Cross-datasource fields via computedColumn methods
+}
+\`\`\`
+
+## Key Properties (set in XML)
+| Property | Description |
+|---|---|
+| \`PublicEntityName\` | OData resource name (singular, PascalCase) |
+| \`PublicCollectionName\` | OData collection name (plural) |
+| \`IsPublic\` | Expose via OData endpoint |
+| \`DataManagementEnabled\` | Enable for DMF import/export |
+| \`EntityCategory\` | One of the 5 categories above |
+| \`StagingTable\` | Auto-generated staging table for DMF |
+
+## OData vs DMF Considerations
+- **OData**: Set \`IsPublic = Yes\`, use \`PublicEntityName\` for the resource name
+- **DMF (Data Management)**: Set \`DataManagementEnabled = Yes\` and define a staging table
+- Both can be enabled simultaneously
+
+## Computed Columns
+For fields that come from complex joins or expressions:
+\`\`\`xpp
+private static server str computePartyName()
+{
+    // Return SQL expression as a string
+    return SysComputedColumn::returnField(tableStr(DirPartyTable), identifierStr(Name));
+}
+\`\`\`
+
+## Keys and Indexes
+- Every entity needs at least one **natural key** (for OData upsert and DMF deduplication)
+- Key fields should be the business identifier (AccountNum, ItemId, etc.) — NOT RecId
+
+## Common Pitfalls
+- After adding fields, run **Refresh entity list** in Data Management workspace
+- Computed columns must return a valid SQL expression string, not an X++ value
+- Mandatory fields on staging table must have defaults or be mapped from source
+- Use \`get_object_info(objectType: "view", name: ...)\` to inspect the current entity's data sources and fields
+
+## Workflow
+1. \`get_object_info(objectType: "data-entity", name: "...")\` — check if entity already exists
+2. \`generate\` — for the staging table if needed
+3. \`d365fo_file(action: "create", objectType: "view", ...)\` — create the entity file
+4. After deployment: refresh entity list in Data Management
+`,
+                        },
+                    },
+                ],
+            };
+        }
+        throw new Error(`Unknown prompt: ${promptName}`);
+    });
+}
+//# sourceMappingURL=codeReview.js.map

package/dist/prompts/codeReview.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codeReview.js","sourceRoot":"","sources":["../../src/prompts/codeReview.ts"],"names":[],"mappings":"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"}

package/dist/prompts/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Prompts module exports
+ */
+export * from './codeReview.js';
+export * from './systemInstructions.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/prompts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/prompts/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC"}

package/dist/prompts/index.js

@@ -0,0 +1,6 @@
+/**
+ * Prompts module exports
+ */
+export * from './codeReview.js';
+export * from './systemInstructions.js';
+//# sourceMappingURL=index.js.map

package/dist/prompts/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/prompts/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC"}

package/dist/prompts/systemInstructions.d.ts

@@ -0,0 +1,33 @@
+/**
+ * System Instructions Prompt for X++ Development
+ * Optimized for MCP-capable AI clients (GitHub Copilot, Claude Code) in Visual Studio 2022 / 2026
+ *
+ * NOTE: This file is the MCP prompt source of truth for AI system instructions.
+ * The static instruction layers (.github/copilot-instructions.md, CLAUDE.md)
+ * mirror these rules. If you update rules here, sync them there too.
+ *
+ * Kept deliberately under 200 lines: the prompt holds only the tool decision
+ * tree and hard prohibitions. Everything that is a rule about CODE lives in
+ * the queryable knowledge base — get_xpp_knowledge (see the ID table below).
+ */
+/**
+ * Get the system instructions prompt definition
+ */
+export declare function getSystemInstructionsPromptDefinition(): {
+    name: string;
+    description: string;
+    arguments: never[];
+};
+/**
+ * Handle the system instructions prompt request
+ */
+export declare function handleSystemInstructionsPrompt(): {
+    messages: {
+        role: string;
+        content: {
+            type: string;
+            text: string;
+        };
+    }[];
+};
+//# sourceMappingURL=systemInstructions.d.ts.map

package/dist/prompts/systemInstructions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"systemInstructions.d.ts","sourceRoot":"","sources":["../../src/prompts/systemInstructions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;GAEG;AACH,wBAAgB,qCAAqC;IAEjD,IAAI;IACJ,WAAW;IACX,SAAS;EAEZ;AAED;;GAEG;AACH,wBAAgB,8BAA8B;;;;YAMpC,IAAI;YACJ,IAAI;;;EAwHb"}