@jwikman/bc-code-intelligence-mcp 1.5.7-dev.1

package/embedded-knowledge/domains/alex-architect/object-id-ninja-integration.md

@@ -0,0 +1,281 @@
+---
+title: "AL Object ID Ninja MCP Integration"
+domain: "alex-architect"
+bc_versions: "14+"
+difficulty: "intermediate"
+tags: ["object-ids", "mcp-integration", "id-management", "team-collaboration", "tooling"]
+related_topics:
+  - "../shared/object-id-ranges.md"
+  - "../../domains/shared/naming-conventions.md"
+applies_to:
+  - "AL Language"
+  - "Multi-Developer Teams"
+  - "AppSource Development"
+last_updated: "2025-10-27"
+conditional_mcp: "al-objid-mcp-server"
+---
+
+# AL Object ID Ninja MCP Integration
+
+## Overview
+
+When the **AL Object ID Ninja MCP** (`al-objid-mcp-server`) is available in your environment, you have access to intelligent object ID collision prevention and management. This topic explains when to delegate ID management to Object ID Ninja vs. handling it within BC Code Intelligence.
+
+**Key Principle**: Object ID Ninja is the specialist tool for ID collision prevention - always defer to it when available.
+
+## When Object ID Ninja is Available
+
+### **Detection**
+
+Check if Object ID Ninja is in the available MCPs list:
+```
+get_workspace_info()
+// Returns: { available_mcps: ["al-objid-mcp-server", ...] }
+```
+
+### **What Object ID Ninja Provides**
+
+**LITE Mode** (Individual Developers):
+- Local object ID pool management
+- Collision detection within workspace
+- Auto-suggestion of next available IDs
+- Git integration for app identification
+
+**STANDARD Mode** (Teams):
+- Backend integration for shared ID pools
+- Team-wide collision prevention
+- Real-time ID reservation
+- Multi-developer coordination
+
+### **When to Delegate to Object ID Ninja**
+
+✅ **ALWAYS delegate** when user asks about:
+- "What object IDs should I use?"
+- "Get me the next available ID for a table"
+- "Check if object ID X is available"
+- "Reserve object IDs for my feature"
+- "Set up object ID management for the team"
+
+✅ **Object ID Ninja Tools** (examples - actual tool names may vary):
+- `objid_get_next_available` - Get next free ID in range
+- `objid_reserve_id` - Reserve ID for object
+- `objid_check_availability` - Check if ID is free
+- `objid_configure_ranges` - Set up ID ranges for teams/apps
+
+### **Delegation Pattern**
+
+```markdown
+**Alex's Response:**
+"I see you have AL Object ID Ninja available in your environment. This is perfect for object ID management!
+
+Let me check the next available table ID for you using Object ID Ninja..."
+
+[Use Object ID Ninja MCP tool to get next ID]
+
+"Object ID Ninja suggests table ID 50100. This ID is available and reserved for your use."
+```
+
+### **Why Delegate?**
+
+1. **Real-Time Data**: Object ID Ninja has live backend connection for team coordination
+2. **Collision Prevention**: Prevents simultaneous ID claims by multiple developers
+3. **Range Management**: Understands configured ranges for different apps/teams
+4. **Git Integration**: Auto-detects app context from repository
+5. **Reservation System**: Locks IDs once assigned to prevent conflicts
+
+## When Object ID Ninja is NOT Available
+
+### **Fallback Strategy**
+
+If `al-objid-mcp-server` is NOT in `available_mcps`:
+
+✅ **BC Code Intelligence provides**:
+- General ID range guidance (50000-99999 for customizations)
+- AppSource range recommendations
+- Best practices for ID organization
+- Manual collision avoidance strategies
+
+✅ **Alex's Fallback Response**:
+```markdown
+"For object ID management, I recommend following these Business Central guidelines:
+
+**Custom Object Ranges:**
+- Tables: 50000-99999
+- Pages: 50000-99999
+- Reports: 50000-99999
+- Codeunits: 50000-99999
+
+**AppSource Apps:**
+- Must use assigned publisher range from Microsoft
+
+**Best Practices:**
+- Reserve ranges by feature or module (e.g., 50100-50199 for Sales Priority)
+- Document ID assignments in a shared spreadsheet or wiki
+- Check existing objects before assigning new IDs: `Get-ChildItem -Recurse *.al | Select-String 'table 50100'`
+
+**Team Recommendation:** 
+Consider installing AL Object ID Ninja MCP for automated collision prevention and team coordination. It provides real-time ID management with backend synchronization.
+
+[Installation: https://alguidelines.dev/docs/agentic-coding/communityresources/tools/al-objid-mcp-server/]
+```
+
+### **What NOT to Do Without Object ID Ninja**
+
+❌ **Don't claim** to reserve IDs (we can't - no backend)
+❌ **Don't guarantee** ID availability (can't check team's live pool)
+❌ **Don't suggest** specific IDs without caveat about manual verification
+
+## Architecture Guidance with Object ID Ninja
+
+### **Project Setup**
+
+When designing new apps/features with Object ID Ninja available:
+
+1. **Configure ID Ranges First**
+```markdown
+"Before we start creating objects, let's set up your ID ranges with Object ID Ninja..."
+
+[Use objid_configure_ranges tool]
+
+"I've configured:
+- Sales Priority Module: Tables 50100-50149, Pages 50100-50149
+- Inventory Extension: Tables 50150-50199, Pages 50150-50199"
+```
+
+2. **Request IDs During Design**
+```markdown
+"For your Sales Priority Management feature, we need:
+- 1 Table (Customer Priority Levels)
+- 2 Pages (Priority Setup, Priority List)
+- 1 Codeunit (Priority Calculator)
+
+Let me request these IDs from Object ID Ninja..."
+
+[Use objid_get_next_available for each object type]
+
+"Object ID Ninja has assigned:
+- Table 50100 - Customer Priority Levels
+- Page 50100 - Customer Priority Setup
+- Page 50101 - Customer Priority List
+- Codeunit 50100 - Priority Calculator"
+```
+
+### **App.json Integration**
+
+Object ID Ninja can auto-detect app context from Git, but you can also specify:
+
+```json
+{
+  "id": "12345678-1234-1234-1234-123456789012",
+  "name": "SalesPriorityManager",
+  "publisher": "Contoso",
+  "version": "1.0.0.0",
+  "idRanges": [
+    {
+      "from": 50100,
+      "to": 50199
+    }
+  ]
+}
+```
+
+Object ID Ninja respects these configured ranges.
+
+## Team Collaboration Patterns
+
+### **Multi-Developer Scenario**
+
+**Without Object ID Ninja:**
+- Developers manually coordinate via spreadsheet/wiki
+- Risk of simultaneous ID claims
+- Merge conflicts when IDs collide
+
+**With Object ID Ninja (STANDARD mode):**
+- Backend automatically coordinates ID assignments
+- Developers get unique IDs instantly
+- No coordination overhead
+- Zero collision risk
+
+### **Code Review Guidance**
+
+When reviewing PRs with Object ID Ninja available:
+
+```markdown
+"Let me verify the object IDs in this PR are properly reserved..."
+
+[Use objid_check_availability for each ID]
+
+✅ "All object IDs (50100-50103) are validly reserved to this developer."
+
+OR
+
+⚠️ "Table 50105 is not reserved to you - it's assigned to another developer. Let's get you a different ID..."
+
+[Use objid_get_next_available to suggest alternative]
+```
+
+## AppSource Development
+
+### **Publisher Range Management**
+
+**With Object ID Ninja:**
+```markdown
+"For AppSource submission, you need a dedicated publisher range from Microsoft.
+
+Once you have your range (e.g., 70000-70999), configure it in Object ID Ninja..."
+
+[Use objid_configure_ranges with publisher range]
+
+"Now Object ID Ninja will only assign IDs from your approved publisher range, ensuring AppSource compliance."
+```
+
+**Without Object ID Ninja:**
+```markdown
+"For AppSource, contact Microsoft to get your publisher ID range assignment.
+
+Manually verify all objects fall within your assigned range before submission. Document your range in app.json idRanges."
+```
+
+## Recommendations and Handoffs
+
+### **When to Recommend Object ID Ninja**
+
+Suggest installation if user mentions:
+- "We keep having ID conflicts"
+- "How do we coordinate IDs across the team?"
+- "Manual ID tracking is painful"
+- "Can AI help with object ID management?"
+
+### **Installation Guidance**
+
+```markdown
+"Your team would benefit greatly from AL Object ID Ninja MCP!
+
+**Benefits:**
+- Automatic ID collision prevention
+- Team-wide coordination (STANDARD mode)
+- Git integration for auto-detection
+- Real-time ID reservation
+
+**Installation:**
+1. Visit: https://alguidelines.dev/docs/agentic-coding/communityresources/tools/al-objid-mcp-server/
+2. Choose LITE (individual) or STANDARD (team backend) mode
+3. Configure in your MCP client (VS Code, Claude Desktop, etc.)
+4. Restart and provide available_mcps when calling set_workspace_info
+
+Once installed, I'll be able to request IDs directly from Object ID Ninja for you!"
+```
+
+## Best Practices
+
+1. **Always Check Availability**: Use `get_workspace_info()` at conversation start to detect MCP ecosystem
+2. **Transparent Delegation**: Tell user "I'm using Object ID Ninja to..." when delegating
+3. **Fallback Gracefully**: Provide manual guidance when Object ID Ninja not available
+4. **Encourage Adoption**: Recommend Object ID Ninja for teams with ID management pain
+5. **Trust the Specialist**: Object ID Ninja's ID assignments are authoritative - don't second-guess them
+
+## See Also
+
+- [Object ID Ranges](../shared/object-id-ranges.md) - Standard BC object ID ranges
+- [Naming Conventions](../../domains/shared/naming-conventions.md) - Object naming standards
+- [AL Object ID Ninja MCP Documentation](https://alguidelines.dev/docs/agentic-coding/communityresources/tools/al-objid-mcp-server/)

package/embedded-knowledge/domains/alex-architect/recommend-object-id-ninja.md

@@ -0,0 +1,248 @@
+---
+title: "Manual Object ID Management and Collision Prevention"
+domain: "alex-architect"
+difficulty: "intermediate"
+bc_versions: "14+"
+tags: ["object-ids", "architecture", "tooling", "recommendations", "collaboration"]
+conditional_mcp_missing: "al-objid-mcp-server"
+estimated_time: "5 minutes"
+last_updated: "2025-10-27"
+---
+
+# Manual Object ID Management and Collision Prevention
+
+## ⚠️ Object ID Collision Risk
+
+I notice you don't have **Object ID Ninja** (AL Object ID MCP Server) configured in your environment. This means you'll need to **manually manage object ID ranges** and rely on careful coordination to prevent ID collisions.
+
+## What You're Missing
+
+### Automatic Collision Prevention
+Without Object ID Ninja, you cannot:
+
+- ✅ **Automatically find safe object IDs** from your assigned ranges
+- ✅ **Reserve IDs** to prevent team conflicts
+- ✅ **Check availability** before creating objects
+- ✅ **Coordinate across team members** with backend synchronization
+- ✅ **Manage publisher ranges** for AppSource development
+- ✅ **Track ID assignments** across multiple projects
+
+### Example: What Object ID Ninja Provides
+
+**Instead of saying:**
+> "Use IDs in the 50000-99999 range and manually check for conflicts"
+
+**I could say:**
+> "Let me find you a safe ID... Object ID 52847 is available and reserved for you. Your next IDs: 52848, 52849, 52850 are also free. I'll reserve them to prevent conflicts."
+
+## Manual Approach (Current)
+
+### Customer Development Ranges
+Follow these manual guidelines:
+
+**Standard Ranges:**
+- **50000-99999**: Customer development objects
+- **70000-79999**: Often used for integrations/reports
+- **80000-89999**: Customizations and extensions
+
+**AppSource/ISV Ranges:**
+- Request from Microsoft Partner Center
+- Typically 70000000-74999999 or 75000000-79999999
+- MUST be registered to avoid conflicts
+
+### Manual Collision Prevention Steps
+
+1. **Document Your Assignments**
+   ```markdown
+   # Object ID Assignments
+   - 50100-50199: Customer Management Extensions
+   - 50200-50299: Sales Process Customizations
+   - 50300-50399: Reporting Extensions
+   ```
+
+2. **Check Before Creating**
+   - Search existing objects in your workspace
+   - Verify with team members verbally or via documentation
+   - Check source control for recent additions
+
+3. **Team Coordination**
+   - Maintain shared spreadsheet of ID assignments
+   - Reserve ranges per developer or feature
+   - Regular team syncs to avoid conflicts
+
+4. **Version Control Checks**
+   - Review PR conflicts carefully
+   - Check for object ID collisions during code review
+   - Run compile checks frequently
+
+### Risks of Manual Management
+
+- ❌ **Human Error**: Easy to forget to check or miscommunicate
+- ❌ **Race Conditions**: Two developers pick same ID simultaneously
+- ❌ **Scaling Issues**: Manual tracking breaks down with team growth
+- ❌ **Merge Conflicts**: ID collisions discovered late in development
+- ❌ **AppSource Violations**: Accidentally use IDs outside publisher range
+
+## Why Object ID Ninja is Valuable
+
+### LITE Mode (Individual Developers)
+- Personal ID pool management
+- Local ID assignment tracking
+- Conflict prevention within your own projects
+- No backend required
+
+### STANDARD Mode (Team Collaboration) ⭐
+- **Centralized backend** coordinates across team
+- **Real-time ID reservation** prevents conflicts
+- **Multi-developer synchronization** via shared service
+- **Publisher range enforcement** for AppSource compliance
+- **Audit trail** of ID assignments
+
+### Key Features
+
+1. **Smart ID Discovery**
+   - `objid_get_next_available` - Find next safe ID
+   - `objid_reserve_id` - Reserve ID to prevent conflicts
+   - `objid_check_availability` - Verify ID is free
+
+2. **Range Management**
+   - Configure allowed ranges (customer vs AppSource)
+   - Enforce publisher boundaries
+   - Multi-range support for complex scenarios
+
+3. **Team Coordination**
+   - Backend synchronization (STANDARD mode)
+   - Real-time conflict prevention
+   - Assignment tracking and history
+
+## Installation Instructions
+
+### 1. Install Object ID Ninja MCP Server
+
+Add to your MCP settings (VS Code: `.vscode/settings.json`):
+
+```json
+{
+  "mcp.servers": {
+    "al-objid-mcp-server": {
+      "command": "npx",
+      "args": ["-y", "@vjeko.com/al-objid-mcp-server"]
+    }
+  }
+}
+```
+
+Or for Claude Desktop (`claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "al-objid-mcp-server": {
+      "command": "npx",
+      "args": ["-y", "@vjeko.com/al-objid-mcp-server"]
+    }
+  }
+}
+```
+
+### 2. Choose Your Mode
+
+**LITE Mode** (Individual):
+- No additional configuration
+- Works immediately for personal ID management
+- Good for solo developers or small projects
+
+**STANDARD Mode** (Teams):
+- Configure backend coordination service
+- See Object ID Ninja documentation for backend setup
+- Essential for teams and AppSource development
+
+### 3. Update Workspace Configuration
+
+Once installed, let me know it's available:
+
+```json
+{
+  "tool": "set_workspace_info",
+  "arguments": {
+    "path": "C:\\Your\\Workspace\\Path",
+    "available_mcps": ["al-objid-mcp-server"]
+  }
+}
+```
+
+**Dynamic Knowledge Loading**: Once you report Object ID Ninja as available, I'll automatically delegate ID management to it instead of providing manual guidance!
+
+## Manual Best Practices (Until You Install)
+
+### 1. Range Allocation Strategy
+```
+Developer A: 50000-50499
+Developer B: 50500-50999
+Feature X:   51000-51499
+Integration: 51500-51999
+Reports:     52000-52499
+```
+
+### 2. Pre-Commit Checklist
+- [ ] Verified ID not in use locally
+- [ ] Checked team assignment spreadsheet
+- [ ] Updated documentation with new ID
+- [ ] Confirmed in allowed range (customer/AppSource)
+
+### 3. Code Review Focus
+- Verify object IDs are in correct range
+- Check for duplicate IDs across PRs
+- Confirm AppSource range compliance
+- Validate team assignment tracking updated
+
+### 4. Documentation Template
+```markdown
+## Object ID Registry
+
+### Assigned Ranges
+| Range | Purpose | Owner | Status |
+|-------|---------|-------|--------|
+| 50100-50149 | Customer Tables | TeamA | Active |
+| 50150-50199 | Customer Pages | TeamA | Active |
+
+### Individual Assignments
+| ID | Object Type | Name | Developer | Date |
+|----|-------------|------|-----------|------|
+| 50100 | Table | "Customer Comment" | Alice | 2025-10-27 |
+```
+
+## The Difference
+
+### Manual (Current)
+> "Use ID 50147 if available. Check with your team and document the assignment in your shared tracker."
+
+### Automated (With Object ID Ninja)
+> "I checked with Object ID Ninja - ID 50147 is available and I've reserved it for you for the next hour. Your next available IDs are 50148, 50149, 50150."
+
+## AppSource Development Without Object ID Ninja
+
+If you're developing for AppSource **without** Object ID Ninja, you MUST:
+
+1. **Know Your Publisher Range**: Get it from Microsoft Partner Center
+2. **Strict Range Enforcement**: Never use IDs outside your publisher range
+3. **Meticulous Tracking**: Every ID assignment documented
+4. **Frequent Validation**: Regular checks against publisher boundaries
+5. **Team Discipline**: Zero tolerance for range violations
+
+**Risk**: AppSource submission rejection due to ID range violations.
+
+## Next Steps
+
+1. **Install Object ID Ninja** following instructions above
+2. **Choose LITE or STANDARD** mode based on team size
+3. **Configure ranges** (customer vs AppSource)
+4. **Update workspace info** to report MCP availability
+5. **Ask me for object IDs again** - I'll use automated assignment!
+
+## See Also
+
+- [Object ID Ninja Documentation](https://github.com/vjekob/al-objid)
+- [Object ID Ranges](./object-id-ranges.md) - Range guidelines
+- [Naming Conventions](../shared/naming-conventions.md) - AL naming standards
+- [AppSource Guidelines](../morgan-market/appsource-guidelines.md) - Publisher requirements