Mps Model Manipulation

Name: Mps Model Manipulation
Author: jetbrains

Use when writing or editing MPS BaseLanguage code that lives inside a model — behavior methods, typesystem rules, checking rules, generator queries, constraints, intentions, scope/canBe callbacks, dataflow builders — and combines the `smodel`, `collections`, and `closures` language extensions. Covers querying nodes (`.descendants<C>`, `.ancestor<C>`, `.children`, `.parent`, `containingRoot`), filtering sequences (`.where`, `.select`, `.translate`, `.ofConcept<C>`), building closures (`{ it => ... }`, `yield`, recursion), creating and mutating nodes (`new node<C>()`, `add new(C)`, `set new(C)`, `replace with new(C)`, `.detach`, `.copy`), property and link access (`SPropertyAccess`, `SLinkAccess`, `SLinkListAccess`), reference operations (`.reference/C : role/`, `.target`), null-safe node equality (`:eq:` / `:ne:`), smodel/Java type casts (`node:C`, `node as C`, `/`, `downcast`), foreach choice, the `command` / `read action` lock wrappers, and JSON blueprints for every shape the Java parser cannot produce.

jetbrains 40b83f6 19 files · 146.3 KB Updated Sep 17, 2026

AI & ML

Install

Press C to copy

$ npx skillmds@latest add jetbrains/mps-model-manipulation

Installs into ~/.claude/skills (or .claude/skills inside a project). Restart Claude Code to pick it up.

Download .zip

＋ Add to collection

README badge

[![SkillMD](https://skillmd.com/badge/jetbrains/mps-model-manipulation.svg)](https://skillmd.com/skills/jetbrains/mps-model-manipulation)

Trust & safety

Audits pending

Not yet audited · commit 40b83f6

Works with: Claude Code Claude.ai OpenAI Codex +

File contents

Writing MPS BaseLanguage with smodel / collections / closures

Use this skill when authoring code inside an MPS model where BaseLanguage is mixed with the smodel, collections, and closures extensions: behavior methods, checking/typesystem/dataflow rules, generator query functions, intentions, constraints, scope/canBe callbacks. The mps_mcp_parse_java_and_insert parser understands only plain Java, so most non-trivial code requires hand-built node blueprints — this skill is the catalog.

To enumerate nodes/instances/usages across a scope (a whole project, module, model, or repository) rather than navigating from one root, add the jetbrains.mps.lang.smodel.query language — it supplies #instances / #usages / #nodes / #references / #models / #modules and a with (<scope>) { … } wrapper, the same queries the MPS Console runs. Its results compose with the smodel/collections/closures operations catalogued here. See the mps-console skill.

Critical Directives

Node equality uses :eq: and :ne:, never == or .equals(). Use NPEEqualsExpression / NPENotEqualsExpression. See references/node-equality.md.
Every InferredClosureParameterDeclaration needs a type child, even though MPS infers the type. Use jetbrains.mps.baseLanguage.structure.UndefinedType as placeholder. Omitting it cascades into misleading "different parameter numbers" / "out of search scope" / "operation is not applicable to null" errors. See references/closures-catalog.md.
The Java parser cannot produce smodel/collection types in method return types, cannot parse :Concept casts, .link accesses, .behaviorMethod() calls, or MetaAdapterFactory.getContainmentLink inline. Use LINKS.xxx/CONCEPTS.xxx constants and replace types post-parse. See references/java-parser-capabilities.md.
Mutations need command { … }, reads from non-UI code need read action { … }. There is no separate "write action". Behavior methods and rule bodies already hold the right lock. See references/concurrent-access.md.
Pick the right cardinality: SLinkAccess for 0..1 / 1; SLinkListAccess for 0..n / 1..n. One pair serves both reference links and containment children (there is no SChildAccess/SChildListAccess). Wrong choice triggers "out of search scope" / "access to link X is not expected here". See references/dot-expression-basics.md.
foreach has two concepts: collections ForEachStatement for sequence/list/set, BaseLanguage ForeachStatement for Java arrays/iterables. Wrong choice → type error. See references/foreach-statements.md.
Used-language imports: NF_* operations require jetbrains.mps.lang.actions in the model's used languages; without it, add new initialized(...) etc. fail. See references/property-and-mutation-ops.md and references/openapi-and-dependencies.md.
Never recommend deprecated operations: .role (use .containingLink), .linkDeclaration (use .link), .role on SReference (use .link.name), .concept Node_GetConceptOperation (use node.concept via typesystem).

Common-path workflow

Identify the source-of-truth layer. If the change is to existing logic in a rule/method body, inspect the current node (shallow mps_mcp_print_node) before editing.
Prefer parse_java_and_insert for plain Java method bodies, expression replacements, and field declarations on LINKS/CONCEPTS inner classes. See references/java-parser-capabilities.md.
For smodel/collections/closures constructs not parseable as Java, build the node blueprint by hand. See:
- references/dot-expression-basics.md — the universal DotExpression(operand, operation) chaining pattern, closure literal blueprint, type-cast wrapping rules.
- references/property-and-mutation-ops.md — property reads/writes, add new(C), replace with new(C), sibling inserts.
- references/references-and-queries.md — .ancestor<C>, .descendants<C>, .reference/C:role/, .target, .isInstanceOf, sibling queries.
- references/attribute-access.md — the .@ operator: read/set/remove an attribute (annotation) attached to a node and reach the children/refs/properties it grafts on (generator macros, comments, requirement traces).
For variable declarations and method return types of MPS collection / smodel types, build the type child explicitly — parse_java_and_insert produces a wrong ClassifierType for these in return-type position. See references/variable-declarations.md.
Validate with mps_mcp_check_root_node_problems(nodeReference,>. Re-read generated source_gen/...java only to confirm runtime shape — never to apply fixes. See references/workflows.md.


If imports/dependencies break, add a used language or model dependency via mps_mcp_model_used_language / mps_mcp_model_dependency / mps_mcp_module_dependency. See references/openapi-and-dependencies.md.


If MPS MCP tools are unavailable, do not hand-edit serialized .mps files unless explicitly requested — inspect only and report.
Related Skills

mps-baselanguage — host BaseLanguage statements, expressions, classes; this skill is the smodel/collections/closures overlay.
mps-quotations — < … > quotations and antiquotations for assembling node trees inline; use instead of long blueprint chains where they apply.
mps-aspect-behavior — per-concept method authoring; behavior bodies are the most common host for this skill.
mps-aspect-generator — generator query bodies, $IF$/$MAP_SRC$.mapperFunction, where this skill provides the smodel idioms.
mps-aspect-typesystem — inference and checking rule bodies; uses the same idioms.
mps-aspect-constraints — getScope, canBe*, property validators; same idiom set.
mps-node-editing — programmatic node creation and editing from outside model code (the MCP-tool side rather than smodel-language side).
mps-console — the MPS Console and the jetbrains.mps.lang.smodel.query language (with-statement, #instances/#usages/#nodes/#models/#modules, scopes); use it to run or generate the smodel code in this skill across a project/repository scope, or to insert console commands via mps_mcp_insert_console_command_from_json.

Reference Index

references/golden-rules-and-pitfalls.md — read first when an error looks weird (cascade UnknownDotCall, "out of search scope", "different parameter numbers", List<SNode> vs sequence<node<X>>); collected symptom→cause→fix table.
references/java-parser-capabilities.md — open before calling mps_mcp_parse_java_and_insert. Lists what the parser handles, what it silently mis-types, and the canonical workarounds (LINKS/CONCEPTS pattern, post-parse replace_node_child, signature widening to avoid smodel casts in arguments).
references/workflows.md — step-by-step recipes: adding a new helper method to a checking-rule class, replacing an expression inside a rule body, interacting with source_gen/ artifacts.
references/concept-id-table.md — MetaAdapterFactory hex IDs for BaseLanguage concepts and links (ThrowStatement, CatchClause, TryCatchStatement, VariableReference, etc.) plus persistent node refs for Type, Expression, Classifier, SequenceType, ListType, SNodeType.
references/smodel-concepts-catalog.md — every smodel concept (SNodeType, SLinkAccess, Node_GetAncestorOperation, OfConceptOperation, Concept_*Operation, EnumMember_*, …) with its ID and MPS surface notation. Open when you need to pick a concept and don't remember which one.
references/baselanguage-key-concepts.md — the small set of BaseLanguage concepts that this skill keeps reaching for (DotExpression, ForeachStatement, BlockStatement, NPE*Expression, UndefinedType).
references/concurrent-access.md — command, read action, execute command in EDT, undo-transparent command. Open when writing code that reads/mutates models outside a rule or behavior body.
references/collections-catalog.md — every *Operation from jetbrains.mps.baseLanguage.collections (where/select/translate/any/take/sortBy/reduceLeft/toList/…), the type hierarchy (sequence ⊃ list/set; map), creator concepts, list/set/map mutators, iterator vs modifying_iterator, sorted variants, lazy-vs-eager rule, and the isEmpty/isNotEmpty collections-vs-baselanguage ambiguity.
references/closures-catalog.md — ClosureLiteral parameters/body shape, InferredClosureParameterDeclaration requirements, FunctionType, InvokeFunctionOperation vs InvokeExpression (recursion), YieldStatement, SAM conversion, generated-Java compilation form, runtime jar dependency.
references/dot-expression-basics.md — the universal DotExpression(operand, operation) chaining pattern; closure-literal blueprint (the reusable building block); cardinality cheat-sheet (SLinkAccess vs SLinkListAccess, one pair for both references and children); when to wrap an operand in SNodeTypeCastExpression; navigation blueprints (.link, .parent, .children, .ancestor<C>, .ancestors<C>, .descendants<C> including + include-self form); node:C vs node as C; expr/ (SemanticDowncastExpression) and downcast expr (DowncastExpression) for crossing into Java APIs; .isInstanceOf / .isNotNull / .isNull / .behaviorMethod(args); where / any / translate / list.add blueprints.
references/property-and-mutation-ops.md — read for property reads/writes (SPropertyAccess, assignment, Property_RemoveOperation) and tree mutations (SNodeCreator, add new(C), set new(C), replace with new(C) / replace with(other), .copy, .detach, sibling inserts), including all NF_* factory-initialized variants and the required jetbrains.mps.lang.actions used-language import.
references/references-and-queries.md — Node_GetReferenceOperation (.reference/C:role/), Node_GetReferencesOperation, Reference_GetTargetOperation etc.; plus query operations .siblings/.next-sibling/.prev-sibling*, .containingRoot/.containingLink/.model/.index, .isExactly(C), seq.ofConcept<C>, seq.ofAspect<a>, enum-member operations.
references/attribute-access.md — the .@ operator (AttributeAccess + NodeAttributeQualifier / LinkAttributeQualifier / ChildAttributeQualifier / PropertyAttributeQualifier / AllAttributeQualifier): read, attach/replace (assignable l-value), or remove an attribute, list semantics of multiple attributes (.@role.add(...)), and chain into the children/refs/properties it grafts onto a node. Pairs with mps-aspect-structure-concepts/references/attributes-and-annotations.md (the structure side).
references/link-and-concept-literals.md — standalone link/C : role/ (LinkIdRefExpression, two required refs) and concept/C/ (ConceptIdRefExpression). Open when an API needs an SContainmentLink/SReferenceLink/SConcept argument with no preceding node. operand; covers the distinction from OperationParm_LinkQualifier and RefConcept_Reference.
references/foreach-statements.md — the two foreach concepts (collections ForEachStatement + ForEachVariable / ForEachVariableReference vs BaseLanguage ForeachStatement + LocalVariableDeclaration / VariableReference). Open when iterating produces a typesystem error or when you need to reference the loop variable.
references/node-equality.md — NPEEqualsExpression (:eq:) and NPENotEqualsExpression (:ne:) blueprints and when to use them.
references/variable-declarations.md — type-child choices for locals and return types (node<C>, nlist<C>, node-ptr<C>, concept<C>, search scope, enummember<E>, sequence/list/set<node<C>>, boolean); creator blueprints for new arraylist<node<C>> / new hashset<node<C>> / etc.; the parse-time return-type fix-up blueprints for sequence<node<Type>> and list<node<Type>>.
references/openapi-and-dependencies.md — org.jetbrains.mps.openapi.* interfaces and threading rules (when hand-written Java calls into models); module dependencies vs model dependencies vs used languages, with failure modes ("Concept not imported", "cannot resolve", "Class not found at runtime") and the matching MCP tool to call.

   1---2name: mps-model-manipulation3description: Use when writing or editing MPS BaseLanguage code that lives inside a model — behavior methods, typesystem rules, checking rules, generator queries, constraints, intentions, scope/canBe callbacks, dataflow builders — and combines the `smodel`, `collections`, and `closures` language extensions. Covers querying nodes (`.descendants<C>`, `.ancestor<C>`, `.children`, `.parent`, `containingRoot`), filtering sequences (`.where`, `.select`, `.translate`, `.ofConcept<C>`), building closures (`{ it => ... }`, `yield`, recursion), creating and mutating nodes (`new node<C>()`, `add new(C)`, `set new(C)`, `replace with new(C)`, `.detach`, `.copy`), property and link access (`SPropertyAccess`, `SLinkAccess`, `SLinkListAccess`), reference operations (`.reference/C : role/`, `.target`), null-safe node equality (`:eq:` / `:ne:`), smodel/Java type casts (`node:C`, `node as C`, `/`, `downcast`), foreach choice, the `command` / `read action` lock wrappers, and JSON blueprints for every shape the Java parser cannot produce.4---56# Writing MPS BaseLanguage with smodel / collections / closures78Use this skill when authoring code inside an MPS model where BaseLanguage is mixed with the `smodel`, `collections`, and `closures` extensions: behavior methods, checking/typesystem/dataflow rules, generator query functions, intentions, constraints, scope/canBe callbacks. The `mps_mcp_parse_java_and_insert` parser understands only plain Java, so most non-trivial code requires hand-built node blueprints — this skill is the catalog.910To enumerate nodes/instances/usages across a **scope** (a whole project, module, model, or repository) rather than navigating from one root, add the `jetbrains.mps.lang.smodel.query` language — it supplies `#instances` / `#usages` / `#nodes` / `#references` / `#models` / `#modules` and a `with (<scope>) { … }` wrapper, the same queries the MPS Console runs. Its results compose with the `smodel`/`collections`/`closures` operations catalogued here. See the `mps-console` skill.1112## Critical Directives1314- **Node equality uses `:eq:` and `:ne:`**, never `==` or `.equals()`. Use `NPEEqualsExpression` / `NPENotEqualsExpression`. See `references/node-equality.md`.15- **Every `InferredClosureParameterDeclaration` needs a `type` child**, even though MPS infers the type. Use `jetbrains.mps.baseLanguage.structure.UndefinedType` as placeholder. Omitting it cascades into misleading "different parameter numbers" / "out of search scope" / "operation is not applicable to null" errors. See `references/closures-catalog.md`.16- **The Java parser cannot produce smodel/collection types** in method return types, cannot parse `:Concept` casts, `.link` accesses, `.behaviorMethod()` calls, or `MetaAdapterFactory.getContainmentLink` inline. Use `LINKS.xxx`/`CONCEPTS.xxx` constants and replace types post-parse. See `references/java-parser-capabilities.md`.17- **Mutations need `command { … }`, reads from non-UI code need `read action { … }`**. There is no separate "write action". Behavior methods and rule bodies already hold the right lock. See `references/concurrent-access.md`.18- **Pick the right cardinality**: `SLinkAccess` for `0..1` / `1`; `SLinkListAccess` for `0..n` / `1..n`. One pair serves both reference links and containment children (there is no `SChildAccess`/`SChildListAccess`). Wrong choice triggers "out of search scope" / "access to link X is not expected here". See `references/dot-expression-basics.md`.19- **`foreach` has two concepts**: collections `ForEachStatement` for `sequence`/`list`/`set`, BaseLanguage `ForeachStatement` for Java arrays/iterables. Wrong choice → type error. See `references/foreach-statements.md`.20- **Used-language imports**: NF_* operations require `jetbrains.mps.lang.actions` in the model's used languages; without it, `add new initialized(...)` etc. fail. See `references/property-and-mutation-ops.md` and `references/openapi-and-dependencies.md`.21- **Never recommend deprecated operations**: `.role` (use `.containingLink`), `.linkDeclaration` (use `.link`), `.role` on `SReference` (use `.link.name`), `.concept` `Node_GetConceptOperation` (use `node.concept` via typesystem).2223## Common-path workflow24251. **Identify the source-of-truth layer**. If the change is to existing logic in a rule/method body, inspect the current node (shallow `mps_mcp_print_node`) before editing.262. **Prefer `parse_java_and_insert`** for plain Java method bodies, expression replacements, and field declarations on `LINKS`/`CONCEPTS` inner classes. See `references/java-parser-capabilities.md`.273. **For smodel/collections/closures constructs not parseable as Java**, build the node blueprint by hand. See:28   - `references/dot-expression-basics.md` — the universal `DotExpression(operand, operation)` chaining pattern, closure literal blueprint, type-cast wrapping rules.29   - `references/property-and-mutation-ops.md` — property reads/writes, `add new(C)`, `replace with new(C)`, sibling inserts.30   - `references/references-and-queries.md` — `.ancestor<C>`, `.descendants<C>`, `.reference/C:role/`, `.target`, `.isInstanceOf`, sibling queries.31   - `references/attribute-access.md` — the `.@` operator: read/set/remove an attribute (annotation) attached to a node and reach the children/refs/properties it grafts on (generator macros, comments, requirement traces).324. **For variable declarations and method return types** of MPS collection / smodel types, build the type child explicitly — `parse_java_and_insert` produces a wrong `ClassifierType` for these in return-type position. See `references/variable-declarations.md`.335. **Validate** with `mps_mcp_check_root_node_problems(nodeReference, onlyNodesWithProblems=true)`. Re-read generated `source_gen/...java` only to confirm runtime shape — never to apply fixes. See `references/workflows.md`.346. **If imports/dependencies break**, add a used language or model dependency via `mps_mcp_model_used_language` / `mps_mcp_model_dependency` / `mps_mcp_module_dependency`. See `references/openapi-and-dependencies.md`.3536If MPS MCP tools are unavailable, do not hand-edit serialized `.mps` files unless explicitly requested — inspect only and report.3738## Related Skills3940- `mps-baselanguage` — host BaseLanguage statements, expressions, classes; this skill is the smodel/collections/closures overlay.41- `mps-quotations` — `<` … `>` quotations and antiquotations for assembling node trees inline; use instead of long blueprint chains where they apply.42- `mps-aspect-behavior` — per-concept method authoring; behavior bodies are the most common host for this skill.43- `mps-aspect-generator` — generator query bodies, `$IF$`/`$MAP_SRC$.mapperFunction`, where this skill provides the smodel idioms.44- `mps-aspect-typesystem` — inference and checking rule bodies; uses the same idioms.45- `mps-aspect-constraints` — `getScope`, `canBe*`, property validators; same idiom set.46- `mps-node-editing` — programmatic node creation and editing from outside model code (the MCP-tool side rather than smodel-language side).47- `mps-console` — the MPS Console and the `jetbrains.mps.lang.smodel.query` language (`with`-statement, `#instances`/`#usages`/`#nodes`/`#models`/`#modules`, scopes); use it to run or generate the smodel code in this skill across a project/repository scope, or to insert console commands via `mps_mcp_insert_console_command_from_json`.4849## Reference Index5051- `references/golden-rules-and-pitfalls.md` — read first when an error looks weird (cascade `UnknownDotCall`, "out of search scope", "different parameter numbers", `List<SNode>` vs `sequence<node<X>>`); collected symptom→cause→fix table.52- `references/java-parser-capabilities.md` — open before calling `mps_mcp_parse_java_and_insert`. Lists what the parser handles, what it silently mis-types, and the canonical workarounds (LINKS/CONCEPTS pattern, post-parse `replace_node_child`, signature widening to avoid smodel casts in arguments).53- `references/workflows.md` — step-by-step recipes: adding a new helper method to a checking-rule class, replacing an expression inside a rule body, interacting with `source_gen/` artifacts.54- `references/concept-id-table.md` — `MetaAdapterFactory` hex IDs for BaseLanguage concepts and links (`ThrowStatement`, `CatchClause`, `TryCatchStatement`, `VariableReference`, etc.) plus persistent node refs for `Type`, `Expression`, `Classifier`, `SequenceType`, `ListType`, `SNodeType`.55- `references/smodel-concepts-catalog.md` — every smodel concept (`SNodeType`, `SLinkAccess`, `Node_GetAncestorOperation`, `OfConceptOperation`, `Concept_*Operation`, `EnumMember_*`, …) with its ID and MPS surface notation. Open when you need to pick a concept and don't remember which one.56- `references/baselanguage-key-concepts.md` — the small set of BaseLanguage concepts that this skill keeps reaching for (`DotExpression`, `ForeachStatement`, `BlockStatement`, `NPE*Expression`, `UndefinedType`).57- `references/concurrent-access.md` — `command`, `read action`, `execute command in EDT`, `undo-transparent command`. Open when writing code that reads/mutates models outside a rule or behavior body.58- `references/collections-catalog.md` — every `*Operation` from `jetbrains.mps.baseLanguage.collections` (`where`/`select`/`translate`/`any`/`take`/`sortBy`/`reduceLeft`/`toList`/…), the type hierarchy (`sequence` ⊃ `list`/`set`; `map`), creator concepts, list/set/map mutators, `iterator` vs `modifying_iterator`, sorted variants, lazy-vs-eager rule, and the `isEmpty`/`isNotEmpty` collections-vs-baselanguage ambiguity.59- `references/closures-catalog.md` — `ClosureLiteral` parameters/body shape, `InferredClosureParameterDeclaration` requirements, `FunctionType`, `InvokeFunctionOperation` vs `InvokeExpression` (recursion), `YieldStatement`, SAM conversion, generated-Java compilation form, runtime jar dependency.60- `references/dot-expression-basics.md` — the universal `DotExpression(operand, operation)` chaining pattern; closure-literal blueprint (the reusable building block); cardinality cheat-sheet (`SLinkAccess` vs `SLinkListAccess`, one pair for both references and children); when to wrap an operand in `SNodeTypeCastExpression`; navigation blueprints (`.link`, `.parent`, `.children`, `.ancestor<C>`, `.ancestors<C>`, `.descendants<C>` including `+` include-self form); `node:C` vs `node as C`; `expr/` (`SemanticDowncastExpression`) and `downcast expr` (`DowncastExpression`) for crossing into Java APIs; `.isInstanceOf` / `.isNotNull` / `.isNull` / `.behaviorMethod(args)`; `where` / `any` / `translate` / `list.add` blueprints.61- `references/property-and-mutation-ops.md` — read for property reads/writes (`SPropertyAccess`, assignment, `Property_RemoveOperation`) and tree mutations (`SNodeCreator`, `add new(C)`, `set new(C)`, `replace with new(C)` / `replace with(other)`, `.copy`, `.detach`, sibling inserts), including all `NF_*` factory-initialized variants and the required `jetbrains.mps.lang.actions` used-language import.62- `references/references-and-queries.md` — `Node_GetReferenceOperation` (`.reference/C:role/`), `Node_GetReferencesOperation`, `Reference_GetTargetOperation` etc.; plus query operations `.siblings`/`.next-sibling`/`.prev-sibling*`, `.containingRoot`/`.containingLink`/`.model`/`.index`, `.isExactly(C)`, `seq.ofConcept<C>`, `seq.ofAspect<a>`, enum-member operations.63- `references/attribute-access.md` — the `.@` operator (`AttributeAccess` + `NodeAttributeQualifier` / `LinkAttributeQualifier` / `ChildAttributeQualifier` / `PropertyAttributeQualifier` / `AllAttributeQualifier`): read, attach/replace (assignable l-value), or remove an attribute, list semantics of `multiple` attributes (`.@role.add(...)`), and chain into the children/refs/properties it grafts onto a node. Pairs with `mps-aspect-structure-concepts/references/attributes-and-annotations.md` (the structure side).64- `references/link-and-concept-literals.md` — standalone `link/C : role/` (`LinkIdRefExpression`, two required refs) and `concept/C/` (`ConceptIdRefExpression`). Open when an API needs an `SContainmentLink`/`SReferenceLink`/`SConcept` argument with no preceding `node.` operand; covers the distinction from `OperationParm_LinkQualifier` and `RefConcept_Reference`.65- `references/foreach-statements.md` — the two `foreach` concepts (collections `ForEachStatement` + `ForEachVariable` / `ForEachVariableReference` vs BaseLanguage `ForeachStatement` + `LocalVariableDeclaration` / `VariableReference`). Open when iterating produces a typesystem error or when you need to reference the loop variable.66- `references/node-equality.md` — `NPEEqualsExpression` (`:eq:`) and `NPENotEqualsExpression` (`:ne:`) blueprints and when to use them.67- `references/variable-declarations.md` — type-child choices for locals and return types (`node<C>`, `nlist<C>`, `node-ptr<C>`, `concept<C>`, `search scope`, `enummember<E>`, `sequence/list/set<node<C>>`, `boolean`); creator blueprints for `new arraylist<node<C>>` / `new hashset<node<C>>` / etc.; the parse-time return-type fix-up blueprints for `sequence<node<Type>>` and `list<node<Type>>`.68- `references/openapi-and-dependencies.md` — `org.jetbrains.mps.openapi.*` interfaces and threading rules (when hand-written Java calls into models); module dependencies vs model dependencies vs used languages, with failure modes ("Concept not imported", "cannot resolve", "Class not found at runtime") and the matching MCP tool to call.

  jetbrains/mps/tree/main/.agents/skills/mps-model-manipulation commit 40b83f6e97 
   Related skills
 Browse category 
     RAG Architect 20.4k 
 alirezarezvani·Audited
 Design, tune, and evaluate production RAG pipelines with deterministic tools for chunking, pipeline design, and retrieval evaluation.
  
   Gemini API 14.4k 
 google·Audited
 Guides usage of the Gemini API on Agent Platform with the Google Gen AI SDK, covering SDK usage (Python, JS/TS, Go, Java, C#), capabilities like multimodal inputs, tools, media generation, caching, batch prediction, and Live API.
  
   Agent Protocol 20.4k 
 alirezarezvani
 Defines an inter-agent communication protocol for C-suite agent teams, including invocation syntax, loop prevention, isolation rules, and response formats to coordinate cross-functional analysis and board meetings.
  
   Agent Designer 20.4k 
 alirezarezvani·Audited
 Design multi-agent system architectures, generate tool schemas for Anthropic and OpenAI formats, and evaluate execution logs for cost, latency, and failure bottlenecks.
  
   Agenthub 20.4k 
 alirezarezvani
 Spawns multiple parallel AI agents that compete on the same task using isolated git worktrees, evaluates results, and merges the best solution.
  
   MCP Server Builder 20.4k 
 alirezarezvani·Audited
 Design and ship production-ready MCP servers from OpenAPI contracts instead of hand-written tool wrappers. Supports Python and TypeScript, schema validation, and safe evolution.
  
 
 
  Frequently asked questions
     
 Run npx skillmds@latest add jetbrains/mps-model-manipulation in your terminal (requires Node.js), paste this page's agent-chat prompt into Claude, Cursor, or any MCP-connected agent, or download the SKILL.md file and copy it into your agent's skills directory.
 
   
 Use when writing or editing MPS BaseLanguage code that lives inside a model — behavior methods, typesystem rules, checking rules, generator queries, constraints, intentions, scope/canBe callbacks, dataflow builders — and combines the `smodel`, `collections`, and `closures` language extensions. Covers querying nodes (`.descendants<C>`, `.ancestor<C>`, `.children`, `.parent`, `containingRoot`), filtering sequences (`.where`, `.select`, `.translate`, `.ofConcept<C>`), building closures (`{ it => ... }`, `yield`, recursion), creating and mutating nodes (`new node<C>()`, `add new(C)`, `set new(C)`, `replace with new(C)`, `.detach`, `.copy`), property and link access (`SPropertyAccess`, `SLinkAccess`, `SLinkListAccess`), reference operations (`.reference/C : role/`, `.target`), null-safe node equality (`:eq:` / `:ne:`), smodel/Java type casts (`node:C`, `node as C`, `/`, `downcast`), foreach choice, the `command` / `read action` lock wrappers, and JSON blueprints for every shape the Java parser cannot produce. It is listed under AI & ML on SkillMD.
 
   
 This skill has not completed SkillMD's automated safety review yet. SkillMD never runs a skill's scripts for you; review the SKILL.md before installing.
 
   
 This skill is tagged as working with Claude Code, Claude.ai, OpenAI Codex. SKILL.md is an open format, so most agents that read a skills directory can load it too.
 
   
 Yes. Installing skills from SkillMD is free, and the skill stays under its author's original license.
 
   
 jetbrains (@jetbrains) published this skill. Their other Agent Skills are listed on their SkillMD profile.

   npx skillmds@latest add jetbrains/mps-model-manipulation

Mps Model Manipulation

File contents

Writing MPS BaseLanguage with smodel / collections / closures

Critical Directives

Common-path workflow

Related Skills

Reference Index

Related skills

Frequently asked questions

How do I install the Mps Model Manipulation skill?

What does the Mps Model Manipulation skill do?

Is Mps Model Manipulation safe to use?

Which AI agents work with Mps Model Manipulation?

Is Mps Model Manipulation free to use?

Who published Mps Model Manipulation?