Stats
Actions
Tags
From create-application
Automatically research and create LeanIX Application fact sheets with verified data. Use this skill whenever the user mentions creating applications, adding applications, researching applications, or says phrases like "Create application for X", "Add Application X", "Research application X", or provides an application name/URL to add to the catalog. Also trigger when user mentions application data collection, application research, or app catalog management. This skill automates the entire workflow - always use it rather than doing ad-hoc research.
How this skill is triggered — by the user, by Claude, or both
Slash command
/create-application:skillThe summary Claude sees in its skill listing — used to decide when to auto-load this skill
**YOU ARE THE EXECUTOR** - This skill contains the complete workflow that you must execute directly. When invoked:
YOU ARE THE EXECUTOR - This skill contains the complete workflow that you must execute directly. When invoked:
Think of this skill as your instruction manual - you're the worker following the manual, not a manager delegating to someone else.
Trigger this skill when the user says:
Do NOT trigger for:
Step 1: Parallel Research (YOU execute 13 queries simultaneously)
↓
Step 2: Agent Verification (YOU compare sources and resolve conflicts)
↓
Step 3: Quality Check (YOU validate against criteria)
↓
Step 4: Create & Update (YOU run the GraphQL script)
When the user provides more than one application in a single request (e.g. "Create applications for Slack, Notion, and Figma"), DO NOT process them sequentially. Instead:
For each app in [App1, App2, App3]:
Task(
subagent_type="general-purpose",
description="Create LeanIX application for {App}",
prompt="Read the SKILL.md at /Users/I756819/.claude/plugins/cache/leanix-catalog-research-marketplace/create-application/1.0.0/skills/create-application/skill/SKILL.md and execute the full 4-step workflow to create a LeanIX Application fact sheet for: {App}"
)
Single app: Execute the 4-step workflow yourself (YOU ARE THE EXECUTOR). Multiple apps: Spawn parallel subagents, one per app, all in one message.
Before starting, YOU must:
Verify tools are available:
mcp__perplexity-aicore__perplexity_search — Perplexity searchWebFetch — fetch web pagesLEANIX_API_TOKEN and LEANIX_SUBDOMAIN set in environment (check with echo $LEANIX_API_TOKEN)Check if multiple apps requested — if YES, see Multi-App Parallelism below and spawn one subagent per app before doing anything else.
Apply inline field rules (no guideline file reads needed — rules are embedded below in each step).
Self-Reflection: If you're about to read guideline files or make queries sequentially, STOP — rules are inlined and research must be parallel.
YOU must execute ALL 13 queries in a SINGLE message - this is critical for parallelism.
# Execute all 8 simultaneously in one message
mcp__perplexity-aicore__perplexity_search(query="[App Name] official website URL - find from authoritative sources", model="sonar")
mcp__perplexity-aicore__perplexity_search(query="[App Name] hosting type: Is it SaaS, PaaS, or IaaS? Is it for developers, end-users, or IT teams? What cloud provider?", model="sonar")
mcp__perplexity-aicore__perplexity_search(query="Does [App Name] support SSO (Single Sign-On)? Check for SAML, OAuth, Azure AD, Okta integration", model="sonar")
mcp__perplexity-aicore__perplexity_search(query="[App Name] pricing model and costs - free tier, subscription, usage-based, or enterprise pricing?", model="sonar")
mcp__perplexity-aicore__perplexity_search(query="What product category is [App Name]? Is it cloud platform, developer tool, CRM, project management, etc.?", model="sonar")
mcp__perplexity-aicore__perplexity_search(query="[App Name] aliases, former names, abbreviations, or alternate names", model="sonar")
mcp__perplexity-aicore__perplexity_search(query="Is [App Name] a web application or mobile app? Browser-based or native?", model="sonar")
mcp__perplexity-aicore__perplexity_search(query="[App Name] description - what does it do? Core capabilities? Factual description without marketing", model="sonar")
# Execute all 5 simultaneously in the same message as Perplexity
WebFetch(url="https://[app-domain]", prompt="Extract: name, description, type indicators, hosting info, SSO mentions")
WebFetch(url="https://[app-domain]/security", prompt="Extract: SSO support, authentication methods, security features")
WebFetch(url="https://[app-domain]/pricing", prompt="Extract: pricing model, tiers, features by plan")
WebFetch(url="https://[app-domain]/about", prompt="Extract: company background, former names, aliases")
WebFetch(url="https://[app-domain]/changelog", prompt="Extract: SSO announcements, major features, hosting updates")
Critical: All 13 queries go in ONE message with 13 tool calls. This achieves true parallelism.
Handle redirects: If WebFetch returns a redirect, immediately make a new WebFetch call with the redirect URL in your next message.
For each field, YOU compare Perplexity vs WebFetch and resolve conflicts:
For each field:
1. Extract value from Perplexity
2. Extract value from WebFetch
3. Compare:
- ✓ MATCH → Use agreed value (HIGH confidence)
- ⚠ CONFLICT → Apply resolution rule (see below)
- ❌ MISSING → Use available source (MEDIUM confidence)
4. Check for marketing language (descriptions only)
5. Record confidence level
For descriptions, detect and remove:
Create verified data with confidence tracking:
{
"webpageUrl": {"value": "...", "confidence": "high", "source": "both_agree"},
"hostingType": {"value": "saas", "confidence": "high", "source": "both_agree"},
"hostingDescription": {"value": "...", "confidence": "high", "source": "webfetch"},
"ssoStatus": {"value": "supported", "confidence": "high", "source": "both_plus_changelog"},
"pricingUrl": {"value": "...", "confidence": "high", "source": "webfetch_pricing"},
"pricingType": {"value": "...", "confidence": "high", "source": "both_agree"},
"productCategory": {"value": "...", "confidence": "high", "source": "webfetch"},
"alias": {"value": "", "confidence": "high", "source": "both_agree_none"},
"category": {"value": "businessApplication", "confidence": "high", "source": "fixed"},
"description": {"value": "...", "confidence": "high", "source": "perplexity", "word_count": 66},
"collectionStatus": {"value": "inReview", "confidence": "high", "source": "fixed"},
"deprecated": {"value": "No", "confidence": "high", "source": "fixed"},
"asOfDate": {"value": "YYYY-MM-DD", "confidence": "high", "source": "current_date"}
}
Validate before proceeding:
If all checks pass:
✓ Quality check PASSED - Proceeding to Step 4
Overall confidence: 95%
All critical fields present
If any check fails:
⚠ Quality check FAILED:
- Issue: Description too short (22 words, need 30-90)
- Issue: Marketing language detected: "revolutionary", "cutting-edge"
Action: Fix issues before proceeding
Everything is done with a single GraphQL script — no LeanIX MCP calls needed. The script: creates the fact sheet, then immediately patches all fields (including description) in one operation.
Required Environment (already set in ~/.zshrc):
LEANIX_API_TOKEN — starts with LXT_LEANIX_SUBDOMAIN — e.g. demo-eu-10Fill in all {placeholder} values from Step 2 verified data before running.
Leave any unknown optional fields as empty string "" — they are filtered out automatically.
python3 << 'PYEOF'
import urllib.request, urllib.parse, json, ssl, base64, os
API_TOKEN = os.environ['LEANIX_API_TOKEN']
SUBDOMAIN = os.environ['LEANIX_SUBDOMAIN']
# ── 1. Authenticate ──────────────────────────────────────────────────────────
ctx = ssl.create_default_context()
auth_data = urllib.parse.urlencode({'grant_type': 'client_credentials'}).encode()
credentials = base64.b64encode(f'apitoken:{API_TOKEN}'.encode()).decode()
with urllib.request.urlopen(urllib.request.Request(
f'https://{SUBDOMAIN}.leanix.net/services/mtm/v1/oauth2/token',
data=auth_data,
headers={'Authorization': f'Basic {credentials}', 'Content-Type': 'application/x-www-form-urlencoded'}
), context=ctx) as r:
bearer = json.loads(r.read())['access_token']
def gql(query, variables=None):
payload = json.dumps({'query': query, 'variables': variables or {}}).encode()
with urllib.request.urlopen(urllib.request.Request(
f'https://{SUBDOMAIN}.leanix.net/services/pathfinder/v1/graphql',
data=payload,
headers={'Authorization': f'Bearer {bearer}', 'Content-Type': 'application/json'}
), context=ctx) as r:
return json.loads(r.read())
# ── 2. Create fact sheet ─────────────────────────────────────────────────────
APP_NAME = "{appName}"
create_result = gql('''
mutation createFS($input: BaseFactSheetInput!, $patches: [Patch]) {
createFactSheet(input: $input, patches: $patches) {
factSheet { id name }
}
}''', {
'input': {'name': APP_NAME, 'type': 'Application'},
'patches': []
})
if 'errors' in create_result:
# Fact sheet may already exist — look it up
print(f"Create error (may already exist): {create_result['errors'][0]['message']}")
search_result = gql('''
{ allFactSheets(filter: {facetFilters: [{facetKey: "FactSheetTypes", keys: ["Application"]}], fullTextSearch: "%s"}) {
edges { node { id name } }
}}''' % APP_NAME)
matches = [e['node'] for e in search_result['data']['allFactSheets']['edges']
if e['node']['name'].lower() == APP_NAME.lower()]
if not matches:
print("ERROR: Could not find or create fact sheet. Aborting.")
exit(1)
fact_sheet_id = matches[0]['id']
print(f"Found existing fact sheet: {fact_sheet_id}")
else:
fact_sheet_id = create_result['data']['createFactSheet']['factSheet']['id']
print(f"✓ Created fact sheet: {APP_NAME} ({fact_sheet_id})")
# ── 3. Build patches (all fields in one mutation) ────────────────────────────
fields = {
'/description': "{description}",
'/webpageUrl': "{webpageUrl}",
'/hostingType': "{hostingType}",
'/hostingDescription':"{hostingDescription}",
'/ssoStatus': "{ssoStatus}",
'/pricingUrl': "{pricingUrl}",
'/pricingType': "{pricingType}",
'/productCategory': "{productCategory}",
'/collectionStatus': "inReview",
'/deprecated': "No",
'/asOfDate': "{asOfDate}",
}
patches = [{'op': 'replace', 'path': k, 'value': v} for k, v in fields.items() if v]
# ── 4. Apply all patches in one call ─────────────────────────────────────────
update_result = gql('''
mutation updateFS($id: ID!, $patches: [Patch]!) {
updateFactSheet(id: $id, patches: $patches, validateOnly: false) {
factSheet { id name
... on Application {
description webpageUrl hostingType pricingType
productCategory collectionStatus asOfDate
}
}
}
}''', {'id': fact_sheet_id, 'patches': patches})
if 'errors' in update_result:
print('UPDATE ERRORS:', json.dumps(update_result['errors'], indent=2))
else:
fs = update_result['data']['updateFactSheet']['factSheet']
print(f"✓ All fields updated: {fs['name']} ({fs['id']})")
print(f" hostingType : {fs.get('hostingType')}")
print(f" pricingType : {fs.get('pricingType')}")
print(f" productCategory: {fs.get('productCategory')}")
print(f" collectionStatus: {fs.get('collectionStatus')}")
print(f" asOfDate : {fs.get('asOfDate')}")
print(f" LeanIX URL : https://{SUBDOMAIN}.leanix.net/factsheet/Application/{fs['id']}")
PYEOF
✅ Application Created Successfully!
Application: [Name]
Overall Confidence: 95% (HIGH)
Verified Data Summary:
├─ Webpage URL: https://... ✓✓ (both sources)
├─ Hosting Type: paas ✓✓ (both sources)
├─ SSO Status: supported ✓✓✓ (both + changelog)
├─ Pricing Type: usage-based ✓ (official page)
├─ Product Category: Development / DevOps ✓✓
├─ Aliases: (none found) ✓✓
└─ Description: 66 words ✓✓ (factual)
Conflicts Resolved: 1
- Pricing model: Used official page over general description
Fixed Fields Set:
├─ Collection Status: inReview ✓
├─ Deprecated: No ✓
└─ As-of Date: 2026-02-23 ✓
LeanIX URL: https://demo-eu-10.leanix.net/ltlsCollectionTesting/factsheet/Application/{id}
Status: Ready for review team approval
✗ Perplexity MCP unavailable
✓ WebFetch working
Action: Use WebFetch data only
Confidence: Downgraded to MEDIUM
Proceed: YES (website is official source)
✓ Perplexity working with citations
✗ WebFetch timeout/blocked
Action: Use Perplexity data only
Confidence: MEDIUM to HIGH (depends on citations)
Proceed: YES (authoritative sources cited)
✗ Perplexity error
✗ WebFetch blocked
Action: CANNOT PROCEED
Tell user: "Unable to research [App]. Please provide data manually or try later."
⚠ No explicit SSO evidence found
⚠ Not stated as "not supported"
Action: Leave ssoStatus blank
Rationale: Better blank than guessing
Error: LEANIX_API_TOKEN not set
Action: Source ~/.zshrc first:
source ~/.zshrc
python3 << 'PYEOF' ...
If still missing, ask user for token (starts with 'LXT_').
Decision Tree:
Examples:
Search Priority:
Evidence Required:
Reference: ../guidelines/Application_Product_Category_Guidelines.md (top 50 categories listed)
Strategy:
These always use the same values:
{
"category": "businessApplication",
"collectionStatus": "inReview",
"deprecated": "No",
"asOfDate": "2026-02-23" // Today's date in ISO format
}
❌ Delegating to subagent: YOU execute the workflow, don't spawn an "application-creator" agent ❌ Sequential research: All 13 queries must run in parallel (one message, 13 tool calls) ❌ Skipping guidelines: Must read all 11 before starting ❌ Accepting marketing language: Detect and rewrite to factual statements ❌ Guessing SSO status: Leave blank if no clear evidence ❌ Using generic categories: Be specific ("Project Management" not "Business Software") ❌ Skipping quality check: Validate before proceeding to Step 4 ❌ Wrong date format: Must be YYYY-MM-DD (ISO 8601)
Create workspace for tracking:
mkdir -p ../executions/[App_Name]
Save outputs:
final_fields.json - Verified data ready for LeanIXCOMPLETION_REPORT.md - Full research summaryparallel_research.json - Raw research data (optional)Your role: Execute the 4-step workflow directly Key principle: Parallel research → Verification → Quality check → Create Success criteria: 95%+ confidence, all validations passed, LeanIX entry created Time commitment: ~2-3 minutes total (most time in Step 1 parallelism)
Remember: YOU are the executor following this workflow, not a coordinator delegating to others. Read, execute, verify, create - that's your job.
npx claudepluginhub vineetgoyal1/leanix-catalog-research-marketplace --plugin create-applicationBuilds Salesforce Lightning Experience apps from natural language by generating all required metadata types (objects, fields, pages, tabs, security) in dependency order.
Orchestrates the Falcon Foundry app lifecycle from requirements through deployment using CLI commands. Triggers when creating, planning, or building a Foundry app.
Produces a complete service catalog entry for a microservice or internal platform service, covering identity, purpose, architecture, SLAs, API contracts, data classification, dependencies, and runbooks.