LeanIX Automation Assistant

Comprehensive help for LeanIX Run Script automations: create, debug, design, optimize, and learn.

CRITICAL: API Access

All LeanIX API calls use MCP tools. No shell commands, no token exchange, no curl.

• Authentication is handled internally by the MCP server
• No bearer tokens need to be managed in the skill workflow
• No .mcp.json parsing is required — MCP handles credentials automatically

Before any LeanIX tool call: if only mcpleanixauthenticate and mcpleanixcomplete_authentication are available, tell the user to run /mcp and authenticate the leanix server (browser opens automatically). Do NOT call authenticate yourself or suggest claude mcp add — the former returns a URL without triggering the browser flow (copy-paste UX), the latter would shadow the plugin's bundled server. If /mcp doesn't surface tools after auth, treat it as a plugin bug.

Anti-Patterns (Don't Do This)

Quick Reference

Trigger limitations:

• Relation is removed - Can't see removed relation (use reconciliation)
• Lifecycle state reached - Nightly only
• Completion score changed - Fires on almost any edit

Common patterns:

// Safe edge/node access
const items = (fs.rel?.edges || []).map(e => e?.node).filter(Boolean);

// Idempotency check
if (newValue === currentValue) return {};

// Revision tracking
currentRev = mutJson?.data?.updateFactSheet?.factSheet?.rev ?? currentRev;

Greeting

When this skill is invoked, display this welcome message:

SAP LeanIX Automation Assistant

Welcome! I help you build, debug, and optimize LeanIX automations—using built-in actions when possible, scripts only when needed.

Reference Files (Progressive Disclosure)

Load these files only when needed for specific workflow steps:

Workflow

Step 0: Determine Intent

When invoked, use a two-tier AskUserQuestion flow to determine the user's intent:

IMPORTANT: AskUserQuestion supports 2-4 options only. Never pass more than 4 options. If more choices exist, group them or use a follow-up question.

Question 1: What type of help do you need?

Question 2 (based on selection):

Branch to the appropriate workflow based on final response.

Step 0.1: Verify Automations Toolset

Run immediately after determining intent (before any other MCP call):

Call mcpleanixlist_automations(). This is a lightweight check that confirms the automations toolset is active.

If the call succeeds: Continue to the next step silently (no message needed).

If the tool is not found / not available:

The automations toolset is optional and hidden by default. Display this message to the user:

Automation tools are not available. Your MCP connection is missing the automations toolset.

Fix: Add ?toolsets=inventory,automations to your MCP server URL.

Claude Code (OAuth):
```
claude mcp remove leanix
claude mcp add --transport http leanix "https://mcp.leanix.net/services/mcp-server/v1/mcp?toolsets=inventory,automations";
```

Claude Code (.mcp.json): Change the URL to:
```
https://{SUBDOMAIN}.leanix.net/services/mcp-server/v1/mcp?toolsets=inventory,automations
```

After updating, restart Claude Code and re-invoke /automations-toolkit.

Then stop the workflow — do not continue without automation tools, as deployment will fail.

If MCP is not connected at all (no mcpleanix* tools available):

No LeanIX MCP connection detected. This skill requires the LeanIX MCP server.

Quickest setup:
```
claude mcp add --transport http leanix "https://mcp.leanix.net/services/mcp-server/v1/mcp?toolsets=inventory,automations";
```

See [MCP Setup](../../MCP-SETUP.md) for full instructions.

Step 0.5: Schema Reference Check (Optional)

After the user selects a workflow, optionally verify schema awareness:

Run: mcpleanixgetautomationschema()

This returns the live trigger, condition, and action type reference from the API. Compare against references/API-REFERENCE.md if discrepancies are suspected.

Key principle: Never block the user. Schema checking is informational only.

[Create New Automation] Workflow

Step 1: Workspace Context (Automatic)

MCP handles authentication and workspace connection automatically. No credential extraction or token exchange needed.

Verify connection:

1. Call mcpleanixget_overview() to confirm workspace access and get basic statistics

Get owner ID (when needed for deployment):

• Use mcpleanixsearch_users(email=...) to find a specific user's UUID
• Or use setownertocurrentuser=True on createautomation / updateautomation to assign the authenticated user as owner

Display: Connected to LeanIX workspace - Ready for automatic deployment.

Step 2: Understand the Goal

Ask using AskUserQuestion:

"What do you want this automation to accomplish?"

Step 2.5: Evaluate Action Strategy

Decision Tree:

1. Does goal require reading data from OTHER fact sheets? → Script required
2. Does goal require modifying OTHER fact sheets? → Script required
3. Does goal require conditional logic based on related data? → Script required
4. Can goal be achieved with built-in actions? → Proceed to Step 3
5. Otherwise → Skip to Step 4 (Trigger Strategy for scripts)

Built-in Actions Available:

If built-in actions suffice → Step 3 If script needed → Step 4

Step 3: Configure Actions (Built-in Only)

Use AskUserQuestion with multiSelect to select actions, then gather parameters for each.

Email placeholders use triple braces: {{{factsheet.displayName}}}, {{{link.factsheet}}}

Action ordering: Use startsAfter to chain actions. For approvals, use onResolution: "ACCEPTED" or "REJECTED".

See [API Reference](references/API-REFERENCE.md) for detailed action configuration.

After configuring → Select trigger → Step 7.5 (Deploy)

Step 4: Recommend Trigger Strategy

Goal → Trigger Mapping (Common Patterns):

Key insight: "Relation is removed" trigger on source FS can't see the removed relation. Put cleanup on target FS.

See [LeanIX Model](references/LEANIX-MODEL.md) for complete trigger reference.

Step 5: Gather Remaining Details

Collect:

1. Fact Sheet Type(s)
2. Tag IDs, role IDs, field names (use MCP to discover)
3. Business logic rules (tie-breaker, edge cases)
4. Whether GraphQL API calls are needed

Step 6: Find Similar Examples

Search examples/INDEX.md for patterns:

• tagging/ - Tag manipulation
• subscription-*/ - Subscription sync
• relation-*/ - Relation-based logic
• initiative-management/ - Multi-relation aggregation

Step 7: Generate Script

Critical Rules Checklist:

• main is exported directly (not via re-export or default export)
• main takes zero parameters (data and context are injected globals)
• If main is async, it contains at least one await
• No import statements — only fetch, data, context, JS built-ins
• Wrap relations in type fragments: ... on Application { relApplicationTo... }
• Track currentRev after each mutation
• Include idempotency checks
• Use throw new Error(...) for visible failures (not console.log — captured to stdout, not surfaced in UI)

Return Object Limitations: Can update description, name, tags, lifecycle, custom fields. Cannot update relations, subscriptions, or other fact sheets (use GraphQL).

See [Templates](references/TEMPLATES.md) for script templates.

Step 8: Provide Automation Setup

Document the configuration for manual setup if needed.

Step 7.5: Deploy Action-Only Automation

When no script needed, create automation directly via POST /templates. Requires name, description, factSheetType, ownerId, trigger, conditions, actions, and active: false.

See [API Reference](references/API-REFERENCE.md) for action payload examples and complete DTO structure.

Step 8.5: Pre-Deployment Checklist

Before deploying, verify ALL items:

See [API Reference — Ownership](references/API-REFERENCE.md#ownership-management) for details.

Step 9: Deploy Automation (Script Path)

Two MCP calls:

1. mcpleanixcreateautomationscript(name="Script Name", code=SCRIPT_CODE) — Create script, returns script ID
2. mcpleanixcreateautomation(name="Automation Name", templatejson=TEMPLATE_JSON) — Create automation referencing script ID

Before deploying: Call mcpleanixgetautomationschema() to validate payload against live schema

Success: Report the automation name and ID. The user can find it in LeanIX Admin → Automations.

See [API Reference](references/API-REFERENCE.md) for deployment details and error patterns.

Step 9.5: Verify Deployment

After deployment, verify the automation works:

1. Check deployment succeeded

- Confirm automation appears in LeanIX Admin → Automations - Verify trigger and conditions are configured correctly

1. Test if possible

- If safe to test: Trigger the automation manually on a test fact sheet - Verify expected outcome matches design

1. Review for edge cases

Before marking complete, consider: - What happens if the automation triggers on itself? (idempotency) - What if related fact sheets don't exist? - What if values are already set correctly? - Can this be simpler?

Ask: "Would you like me to review edge cases before we finalize?"

Step 10: Ask for Refinements

Offer:

• Add edge case handling
• Add companion automation (for remove triggers)
• Generate additional scripts for multi-trigger scenarios

[Debug Failing Script] Workflow

Step 1: Collect Information

Request: script code, trigger config, observed behavior, error messages.

Step 2: Automated Diagnostic Checks

Step 3: Provide Diagnosis

Generate diagnostic report with issues found and recommended fixes.

Step 4: Offer Corrected Script

Ask if user wants fully corrected script generated.

[Understand Capabilities] Workflow

Can automate:

• Update fields, tags on triggering fact sheet
• Query/update other fact sheets via GraphQL
• Manage subscriptions, relations, relation attributes
• Send webhooks, emails, create to-dos

Cannot automate:

• Scheduled triggers (use external schedulers)
• Access to "before" state
• Bulk operations on unrelated fact sheets
• User archive events

See [LeanIX Model](references/LEANIX-MODEL.md) for detailed capabilities.

[Refactor/Optimize Script] Workflow

1. Collect current script and desired improvements
2. Check for: unnecessary API calls, missing idempotency, inefficient loops, missing error handling
3. Provide refactored version with explanations

[Convert Azure Function] Workflow

Key conversions:

For scheduled functions: Convert to event-driven, or keep external scheduler.

External Documentation

• references/CRITICAL-RULES.md - Critical rules, common errors, key patterns
• references/TEMPLATES.md - Script templates & GraphQL patterns
• references/LEANIX-MODEL.md - Triggers, actions, capabilities
• references/API-REFERENCE.md - API endpoints & deployment
• examples/INDEX.md - Production scripts

[Analyze Workspace Automations] Workflow

Audit existing automations, update descriptions, and standardize naming conventions.

Speed: Load references/WORKSPACE-ANALYSIS.md + references/NAMING-CONVENTION.md + call mcpleanixgetoverview() + mcpleanixlistautomations() all in one parallel message to avoid sequential round-trips.

See [Workspace Analysis](references/WORKSPACE-ANALYSIS.md) for the full workflow.

[Manage Existing Automations] Workflow

Transfer ownership, enable/disable, troubleshoot, or bulk update existing automations.

See [Manage Automations](references/MANAGE-AUTOMATIONS.md) for the full workflow.