developer-tools Static interface comparison

MetaEngine MCP

1.4.2 1.5.0

FAILPending human review

1 new unknown capability requires explicit review.

View the upgrade review as Markdown

A shareable summary of this comparison for an issue, pull request or ticket. Select the text and copy it.

Tools7 → 8
Added1
Removed0
Schema changes1
Input schema changes1
Output schema changes0
Unclassified schema changes0
Description changes2
New write authority0
New destructive authority0
New unknown authority1
AnalysisFAIL

INTERFACE DIFF

What changed, tool by tool

Classification from the recorded findings · definitions from the published snapshots

3 tools with recorded changes

  1. generate_codeModifiedSchemaDescriptionREVIEWINFO

    What changed

    • generate_code — Schema change: input property added: skipEnumMembersValidation.
    • generate_code: description changed.

    Why it could matter

    • Calls or consumers built for the earlier schema may need to change.
    • Models choose and call tools partly from their descriptions.

    What to verify

    • Validate representative existing tool calls against the new argument schema.
    • Spot-check that agents still select this tool as intended.
    Declared effect
    unknown → unknown
    Description
    PreviousSemantic code generation for TypeScript, Python, Go, C#, Java, Kotlin, Groovy, Scala, Swift, PHP, and Rust. Generates compilable source files with perfect imports and cross-references from structured JSON specs. # MetaEngine MCP — AI Code Generation Guide MetaEngine is a semantic code generation system exposed via MCP. You describe types, relationships, and methods as structured JSON — MetaEngine produces compilable, correctly-imported source files for TypeScript, C#, Python, Go, Java, Kotlin, Groovy, Scala, Swift, and PHP. Unlike templates, it resolves cross-references, manages imports, and handles language idioms automatically. This matters for AI usage because a single well-formed JSON call replaces dozens of error-prone file writes. --- ## Critical Rules These are the rules that cause the most failures when violated. Read them first. ### 1. Generate ALL related types in ONE call `typeIdentifier` references only resolve within the current batch. If `UserService` references `User`, both must be in the same `generate_code` call. ```jsonc // ONE call with both types { "classes": [ {"name": "User", "typeIdentifier": "user", ...}, {"name": "UserService", ...references "user"...} ] } ``` ### 2. Properties = type declarations. CustomCode = everything else. `properties[]` declares fields with types only. `customCode[]` handles methods, initialized fields, and any code with logic. One `customCode` item = exactly one member. ```jsonc // Property: type only, no initialization "properties": [{"name": "id", "primitiveType": "String"}] // CustomCode: method or initialized field "customCode": [ {"code": "private http = inject(HttpClient);"}, {"code": "getAll(): T[] { return this.items; }"} ] ``` **Never put methods in properties.** Never put uninitialized type declarations in customCode. ### 3. Use templateRefs for internal types in customCode When customCode references a type from the same batch, use `$placeholder` syntax with `templateRefs`. This triggers automatic import resolution. Without templateRefs, MetaEngine cannot generate the import/using directive. ```jsonc "customCode": [{ "code": "getUser(): Promise<$user> { ... }", "templateRefs": [{"placeholder": "$user", "typeIdentifier": "user"}] }] ``` **Critical in C#**: Every internal type reference in customCode MUST use templateRefs, or `using` directives for cross-namespace types won't be generated. Raw strings like `IUserRepository` without templateRefs will compile-fail across namespaces. ### 4. Never add framework imports to customImports MetaEngine auto-imports standard library types. Adding them manually causes duplication or errors. | Language | Auto-imported (never specify) | |------------|--------------------------------------------------------------------------------------------------| | C# | System.*, Collections.Generic, Linq, Tasks, Text, IO, Net.Http, DataAnnotations, Extensions.* | | Python | typing.*, pydantic (BaseModel, Field), datetime, decimal, enum, abc, dataclasses | | Java | java.util.*, java.time.*, java.util.stream.*, java.math.*, jakarta.validation.*, jackson.* | | Kotlin | java.time.*, java.math.*, java.util.UUID, kotlinx.serialization.* | | Go | time, fmt, log, strings, strconv, errors, context, sync, io, os, encoding/json, net/http, +more | | Swift | Foundation (Date, UUID, URL, Decimal, URLSession, JSONEncoder, JSONDecoder, etc.) | | Rust | std::collections (HashMap, HashSet), chrono, uuid, rust_decimal, serde | | Groovy | java.time.*, java.math.*, java.util (UUID, Date), java.io (File, InputStream, OutputStream) | | Scala | java.time.*, scala.math (BigDecimal, BigInt), java.util.UUID, scala.collection.mutable.* | | PHP | DateTime*, DateTimeImmutable, Exception*, ArrayObject, JsonSerializable, Stringable | | TypeScript | (no imports needed — built-in types) | Only use `customImports` for external libraries (`@angular/core`, `FluentValidation`, `rxjs`, etc.). ### 5. templateRefs are ONLY for internal types External library types must use `customImports`. If it's in the same MCP call → use `typeIdentifier` or `templateRefs`. If it's an external library → use `customImports`. Never mix these. ### 6. Constructor parameters auto-create properties In C#, Java, Go, and Groovy, constructor parameters automatically become class properties. Do NOT duplicate them in `properties[]` — this causes "Sequence contains more than one matching element" errors. ```jsonc // WRONG for C#/Java/Go/Groovy "constructorParameters": [{"name": "email", "type": "string"}], "properties": [{"name": "email", "type": "string"}] // DUPLICATE! // CORRECT — only in constructorParameters "constructorParameters": [{"name": "email", "type": "string"}] // additional non-constructor properties go in properties[] ``` ### 7. Virtual types don't generate files `arrayTypes`, `dictionaryTypes`, `concreteGenericClasses`, and `concreteGenericInterfaces` create reusable type references only. They never produce files. They're used by referencing their `typeIdentifier` in properties of file-generating types. ### 8. Opt in to runtime `.js` imports for Node16/NodeNext TypeScript Node16 and NodeNext ESM execute the emitted JavaScript, so relative imports in the TypeScript source must name the runtime `.js` file. Set the option on `generate_code` or in a `load_spec_from_file` document: ```json { "language": "typescript", "typeScriptOptions": { "relativeImportExtension": "js" } } ``` MetaEngine then emits specifiers such as `./worker.js` and uses `import type` when the imported declaration is intrinsically type-only. Omit `typeScriptOptions` (or select `"none"`) to preserve extensionless relative imports for bundler-oriented projects. --- ## Pattern Reference ### Basic interfaces with cross-references ```jsonc { "language": "typescript", "interfaces": [ {"name": "Address", "typeIdentifier": "address", "properties": [ {"name": "street", "primitiveType": "String"}, {"name": "city", "primitiveType": "String"} ]}, {"name": "User", "typeIdentifier": "user", "properties": [ {"name": "id", "primitiveType": "String"}, {"name": "address", "typeIdentifier": "address"} ]} ] } ``` Produces two files with automatic imports between them. ### Class with inheritance and methods ```jsonc { "classes": [ {"name": "BaseEntity", "typeIdentifier": "base-entity", "isAbstract": true, "properties": [{"name": "id", "primitiveType": "String"}]}, {"name": "User", "typeIdentifier": "user", "baseClassTypeIdentifier": "base-entity", "properties": [{"name": "email", "primitiveType": "String"}], "customCode": [ {"code": "getDisplayName(): string { return this.email; }"} ]} ] } ``` ### Generic class + concrete implementation ```jsonc { "classes": [ {"name": "Repository", "typeIdentifier": "repo-generic", "genericArguments": [{ "name": "T", "constraintTypeIdentifier": "base-entity", "propertyName": "items", "isArrayProperty": true }], "customCode": [ {"code": "add(item: T): void { this.items.push(item); }"}, {"code": "getAll(): T[] { return this.items; }"} ]}, {"name": "User", "typeIdentifier": "user", "baseClassTypeIdentifier": "base-entity", "properties": [{"name": "email", "primitiveType": "String"}]}, {"name": "UserRepository", "typeIdentifier": "user-repo-class", "baseClassTypeIdentifier": "user-repo-concrete", "customCode": [{ "code": "findByEmail(email: string): $user | undefined { return this.getAll().find(u => u.email === email); }", "templateRefs": [{"placeholder": "$user", "typeIdentifier": "user"}] }]} ], "concreteGenericClasses": [{ "identifier": "user-repo-concrete", "genericClassIdentifier": "repo-generic", "genericArguments": [{"typeIdentifier": "user"}] }] } ``` The `concreteGenericClasses` entry creates a virtual `Repository<User>` type. The class extends it via `baseClassTypeIdentifier`. MetaEngine generates `extends Repository<User>` with correct imports. ### Array and dictionary types ```jsonc { "arrayTypes": [ {"typeIdentifier": "user-list", "elementTypeIdentifier": "user"}, {"typeIdentifier": "string-array", "elementPrimitiveType": "String"} ], "dictionaryTypes": [ {"typeIdentifier": "scores", "keyPrimitiveType": "String", "valuePrimitiveType": "Number"}, {"typeIdentifier": "user-lookup", "keyPrimitiveType": "String", "valueTypeIdentifier": "user"} ] } ``` Then reference via `"typeIdentifier": "user-list"` in properties. **C# note**: arrayTypes generate `IEnumerable<T>`. If you need `List<T>`, use `"type": "List<$user>"` with templateRefs instead. ### Complex type expressions with templateRefs ```jsonc "properties": [{ "name": "cache", "type": "Map<string, $resp>", "templateRefs": [{"placeholder": "$resp", "typeIdentifier": "api-response"}] }] ``` templateRefs work in properties, customCode, and decorators. The `$placeholder` gets replaced with the resolved type name and triggers import generation. ### Enum + class that uses it ```jsonc { "enums": [{"name": "OrderStatus", "typeIdentifier": "order-status", "members": [{"name": "Pending", "value": 0}, {"name": "Shipped", "value": 2}]}], "classes": [{"name": "Order", "typeIdentifier": "order", "properties": [{"name": "status", "typeIdentifier": "order-status"}], "customCode": [{ "code": "updateStatus(s: $status): void { this.status = s; }", "templateRefs": [{"placeholder": "$status", "typeIdentifier": "order-status"}] }]}] } ``` Enums auto-suffix filenames: `order-status.enum.ts` (TS), `OrderStatus.cs` (C#). ### Service with external dependency injection ```jsonc { "classes": [{ "name": "ApiService", "typeIdentifier": "api-service", "decorators": [{"code": "@Injectable({ providedIn: 'root' })"}], "customImports": [ {"path": "@angular/core", "types": ["Injectable", "inject"]}, {"path": "@angular/common/http", "types": ["HttpClient"]} ], "customCode": [ {"code": "private http = inject(HttpClient);"}, {"code": "getUsers(): Observable<$list> { return this.http.get<$list>('/api/users'); }", "templateRefs": [{"placeholder": "$list", "typeIdentifier": "user-array"}]} ] }], "arrayTypes": [{"typeIdentifier": "user-array", "elementTypeIdentifier": "user-dto"}] } ``` ### CustomFiles for type aliases and barrel exports ```jsonc { "customFiles": [{ "name": "types", "path": "shared", "identifier": "shared-types", "customCode": [ {"code": "export type UserId = string;"}, {"code": "export type Email = string;"} ] }], "classes": [{ "name": "UserHelper", "path": "helpers", "customImports": [{"path": "shared-types"}], "customCode": [{"code": "static format(email: Email): string { return email.trim(); }"}] }] } ``` The `identifier` on the customFile enables import resolution. `customImports` referencing the identifier auto-resolves to the relative path. ### Interface with method signatures (TypeScript/C#) For interfaces that will be `implements`/`:` by a class, define method signatures in `customCode`, NOT as function-typed properties: ```jsonc { "interfaces": [{ "name": "IUserRepository", "typeIdentifier": "user-repo", "fileName": "i-user-repository", "customCode": [ {"code": "findAll(): Promise<$user[]>;", "templateRefs": [{"placeholder": "$user", "typeIdentifier": "user"}]}, {"code": "findById(id: string): Promise<$user | null>;", "templateRefs": [{"placeholder": "$user", "typeIdentifier": "user"}]} ] }] } ``` If you use function-typed properties instead (e.g. `"type": "() => Promise<User[]>"`), the implementing class will duplicate them as property declarations alongside your customCode methods. --- ## Language-Specific Notes ### TypeScript - MetaEngine strips `I` prefix from interface names. `IUserRepository` → exported as `UserRepository`. Use `fileName` to control the file name if collisions arise. - `Number` → `number`, `String` → `string`, `Boolean` → `boolean`, `Date` → `Date`, `Any` → `unknown` - Auto-indent for customCode newlines (`\n`) - Decorators supported directly ### C# - `I` prefix preserved on interface names - `Number` → `int` (not `double`). Use `"type": "decimal"` or `"type": "double"` for non-integer numbers. - `packageName` sets the namespace. Omit for GlobalUsings pattern. - Interface properties generate `{ get; }`. Class properties generate `{ get; set; }`. - arrayTypes generate `IEnumerable<T>`. For `List<T>`, use `type` with templateRefs: `"type": "List<$user>"` - `isOptional` on properties generates `string?` (nullable reference type) ### Python - Must provide explicit indentation (4 spaces) after `\n` in customCode - typing imports are automatic ### Go - Requires `packageName` for multi-file projects - No constructors — use factory functions in customCode --- ## Common Mistakes 1. **Don't** reference a `typeIdentifier` that doesn't exist in the batch → the property is silently dropped. **Do** verify every typeIdentifier matches a defined type in the same call. 2. **Don't** put method signatures as function-typed properties on interfaces you'll `implements`. **Do** use `customCode` for interface method signatures when a class will implement them. 3. **Don't** write internal type names as raw strings in customCode (e.g., `"code": "private repo: IUserRepository"`). **Do** use templateRefs: `"code": "private repo: $repo"` with `"templateRefs": [{"placeholder": "$repo", "typeIdentifier": "user-repo"}]`. 4. **Don't** use `arrayTypes` in C# when you need `List<T>`. **Do** use `"type": "List<$user>"` with templateRefs for mutable list types. 5. **Don't** add `System.*`, `typing.*`, `java.util.*` etc. to customImports. **Do** let MetaEngine handle all framework imports automatically. 6. **Don't** duplicate constructor parameter names in the `properties` array (C#/Java/Go/Groovy). **Do** put shared fields only in `constructorParameters` and additional-only fields in `properties`. 7. **Don't** use reserved words (`delete`, `class`, `import`) as property names. **Do** use safe alternatives (`remove`, `clazz`, `importData`). 8. **Don't** generate related types in separate MCP calls. **Do** batch everything in one call — cross-file imports only resolve within a single batch. 9. **Don't** expect `Number` to map to `double` in C# — it maps to `int`. **Do** use `"type": "double"` or `"type": "decimal"` explicitly when needed. 10. **Don't** forget `fileName` when both an `I`-prefixed interface and its implementing class would collide in TypeScript. **Do** set `"fileName": "i-user-repository"` on the interface to prevent file name conflicts.
    CurrentGenerate source files from a structured type graph for TypeScript, Python, Go, C#, Java, Kotlin, Groovy, Scala, Swift, PHP, and Rust. Use explicit templateRefs to link target-language customCode to generated types and imports. For compact field maps and repeated patterns, use generate_from_recipe. # MetaEngine MCP — generation guide MetaEngine generates source files from structured type definitions and target-language code. Type and model generation supports TypeScript, Python, Go, C#, Java, Kotlin, Groovy, Scala, Swift, PHP, and Rust. ## Choose a tool - `generate_from_recipe`: compact property maps, explicit references, reusable parameter templates, and local JSON data rows. Start with [RECIPES.md](./RECIPES.md), also available as `metaengine://guide/recipes`. - `generate_code`: the existing complete native JSON payload. - `load_spec_from_file`: the same native payload read from a local file. - `generate_openapi`, `generate_graphql`, `generate_protobuf`, `generate_sql`: convert an existing schema using their tool-specific options. The three type-graph tools share the hosted generation API and local file writer. `dryRun` previews source without writing it; `skipExisting` defaults to true. The hosted request limit is 250 counted types, with the existing counting rule documented in the recipe guide. ## References and batch boundaries Generate related types together. IDs resolve within a single request. A class or interface declares `typeIdentifier`; a property refers to it with the same field. Recipes also accept the compact aliases `id` on definitions and `ref` on map properties. Use `templateRefs` wherever target-language text refers to an internal type: ```json { "code": "read(): Promise<$item>;", "templateRefs": [{ "placeholder": "$item", "typeIdentifier": "item" }] } ``` The reference resolves the type name and supports import generation. Merely writing an internal type's name in a raw code string does not create a graph reference. `templateRefs` are supported on custom code, native property type expressions, constructor parameter type expressions, and decorators; properties also support `commentTemplateRefs`. External types use `customImports` with the target language's import path and names. The generator handles recognized standard-library imports. It does not install external packages. Custom-file identifiers belong to import resolution, not the regular type graph. Where supported, refer to one with `customImports.path`; for C#, use the custom file's namespace. Do not target a custom-file identifier with `ref` or `templateRefs.typeIdentifier`. Code inside a custom file can still use `templateRefs` to refer to ordinary generated types. ## Declarations and custom code Use `properties` for typed declarations. Use `customCode` for methods, initialized fields, constructors with bodies, and other target-language members. Keep each member in its own code block. `customFiles` produce files without a class wrapper and can hold functions, aliases, or other source content. Use interface method signatures in `customCode` when classes will implement those methods. A function-typed property and a method are different declarations. Constructor parameters can create properties in the selected language. Do not repeat a constructor parameter as an additional property. For a constructor with custom logic, supply the constructor code and any fields explicitly in `customCode`. The generator renders your supplied structure and code. Compile the result in its real project to check method bodies, dependencies, language rules, and compiler options. ## Native features retained by recipes | Feature | Native fields | | --- | --- | | Named types | `classes`, `interfaces`, `enums`, `typeIdentifier`, `name`, `path`, `fileName` | | Properties | `name`, `primitiveType`, `typeIdentifier`, `type`, `isOptional`, `isInitializer`, comments and decorators | | Inheritance | `baseClassTypeIdentifier`, `interfaceTypeIdentifiers` | | Generic definitions | `genericArguments` with name, constraint, and optional property metadata | | Concrete generic references | `concreteGenericClasses`, `concreteGenericInterfaces`, `identifier`, `genericClassIdentifier`, `genericArguments` | | Collection references | `arrayTypes`, `dictionaryTypes` | | Target-language content | `customCode`, `customFiles`, `customImports`, `templateRefs` | | Generation settings | `initialize`, `packageName`, `typeScriptOptions`, `skipEnumMembersValidation` | Array, dictionary, and concrete generic definitions are virtual types: they can be referenced but do not generate files of their own. A concrete generic's `genericClassIdentifier` refers to its generic declaration, including for interfaces; keep that existing field name. ## Language notes ### TypeScript For Node16/NodeNext ESM, use `typeScriptOptions: {"relativeImportExtension":"js"}` so generated `.ts` source imports runtime `.js` paths. The default uses extensionless relative imports. Native primitives `String`, `Number`, `Boolean`, `Date`, and `Any` render as `string`, `number`, `boolean`, `Date`, and `unknown`. Recipes spell those primitive choices in lowercase. For native expressions such as `Map<string, $item>`, use `type` plus `templateRefs`. The engine can normalize interface names. Use references to obtain the rendered name, and explicit `fileName` values when an interface and class would otherwise share a file name. ### C# `packageName` sets the root namespace; type paths contribute namespace segments. Omit the package name when you want no root namespace. Do not put namespace wrappers in individual custom members. `Number` selects `int`. Use native `type: "decimal"` or `type: "double"` for those numeric types. Optional properties use the language's nullable representation. Configure nullable reference types and the language version in the consuming project. Use `templateRefs` for internal cross-namespace types in custom code. For a specific collection such as `List<T>`, use `type: "List<$item>"` with a reference. The language emitter chooses the collection spelling for a virtual `arrayTypes` definition. ### Other languages Keep method bodies and native type expressions in the selected language. Python bodies need valid indentation. Go multi-file output needs a package/module layout appropriate to the consuming project. Add the generated code's required libraries to the target project. ## Before generation 1. Include every internally referenced type in the same batch. 2. Use structured properties for declarations and custom code for behavior. 3. Make every internal reference in a raw type expression or code block explicit with `templateRefs`. 4. Choose output paths, native imports, package/namespace names, and compiler options deliberately. 5. Review and compile the generated output. [Complete examples](./EXAMPLES.md) · [Recipe syntax and limits](./RECIPES.md)

    Input schema

    PropertyPrevious (1.4.2)Current (1.5.0)Change
    skipEnumMembersValidationnot presentbooleanoptional
    • Added
    150 unchanged entries
    • (schema root)
    • arrayTypes
    • arrayTypes › [items]
    • arrayTypes › [items] › elementPrimitiveType
    • arrayTypes › [items] › elementTypeIdentifier
    • arrayTypes › [items] › typeIdentifier
    • classes
    • classes › [items]
    • classes › [items] › baseClassTypeIdentifier
    • classes › [items] › comment
    • classes › [items] › constructorParameters
    • classes › [items] › constructorParameters › [items]
    • classes › [items] › constructorParameters › [items] › name
    • classes › [items] › constructorParameters › [items] › primitiveType
    • classes › [items] › constructorParameters › [items] › templateRefs
    • classes › [items] › constructorParameters › [items] › templateRefs › [items]
    • classes › [items] › constructorParameters › [items] › templateRefs › [items] › placeholder
    • classes › [items] › constructorParameters › [items] › templateRefs › [items] › typeIdentifier
    • classes › [items] › constructorParameters › [items] › type
    • classes › [items] › constructorParameters › [items] › typeIdentifier
    • classes › [items] › customCode
    • classes › [items] › customCode › [items]
    • classes › [items] › customCode › [items] › code
    • classes › [items] › customCode › [items] › templateRefs
    • classes › [items] › customCode › [items] › templateRefs › [items]
    • classes › [items] › customCode › [items] › templateRefs › [items] › placeholder
    • classes › [items] › customCode › [items] › templateRefs › [items] › typeIdentifier
    • classes › [items] › customImports
    • classes › [items] › customImports › [items]
    • classes › [items] › customImports › [items] › path
    • classes › [items] › customImports › [items] › types
    • classes › [items] › customImports › [items] › types › [items]
    • classes › [items] › decorators
    • classes › [items] › decorators › [items]
    • classes › [items] › decorators › [items] › code
    • classes › [items] › decorators › [items] › templateRefs
    • classes › [items] › decorators › [items] › templateRefs › [items]
    • classes › [items] › fileName
    • classes › [items] › genericArguments
    • classes › [items] › genericArguments › [items]
    • classes › [items] › genericArguments › [items] › constraintTypeIdentifier
    • classes › [items] › genericArguments › [items] › isArrayProperty
    • classes › [items] › genericArguments › [items] › name
    • classes › [items] › genericArguments › [items] › propertyName
    • classes › [items] › interfaceTypeIdentifiers
    • classes › [items] › interfaceTypeIdentifiers › [items]
    • classes › [items] › isAbstract
    • classes › [items] › name
    • classes › [items] › path
    • classes › [items] › properties
    • classes › [items] › properties › [items]
    • classes › [items] › properties › [items] › comment
    • classes › [items] › properties › [items] › commentTemplateRefs
    • classes › [items] › properties › [items] › commentTemplateRefs › [items]
    • classes › [items] › properties › [items] › decorators
    • classes › [items] › properties › [items] › decorators › [items]
    • classes › [items] › properties › [items] › decorators › [items] › code
    • classes › [items] › properties › [items] › decorators › [items] › templateRefs
    • classes › [items] › properties › [items] › decorators › [items] › templateRefs › [items]
    • classes › [items] › properties › [items] › isInitializer
    • classes › [items] › properties › [items] › isOptional
    • classes › [items] › properties › [items] › name
    • classes › [items] › properties › [items] › primitiveType
    • classes › [items] › properties › [items] › templateRefs
    • classes › [items] › properties › [items] › templateRefs › [items]
    • classes › [items] › properties › [items] › templateRefs › [items] › placeholder
    • classes › [items] › properties › [items] › templateRefs › [items] › typeIdentifier
    • classes › [items] › properties › [items] › type
    • classes › [items] › properties › [items] › typeIdentifier
    • classes › [items] › typeIdentifier
    • concreteGenericClasses
    • concreteGenericClasses › [items]
    • concreteGenericClasses › [items] › genericArguments
    • concreteGenericClasses › [items] › genericArguments › [items]
    • concreteGenericClasses › [items] › genericArguments › [items] › primitiveType
    • concreteGenericClasses › [items] › genericArguments › [items] › typeIdentifier
    • concreteGenericClasses › [items] › genericClassIdentifier
    • concreteGenericClasses › [items] › identifier
    • concreteGenericInterfaces
    • concreteGenericInterfaces › [items]
    • concreteGenericInterfaces › [items] › genericArguments
    • concreteGenericInterfaces › [items] › genericArguments › [items]
    • concreteGenericInterfaces › [items] › genericArguments › [items] › primitiveType
    • concreteGenericInterfaces › [items] › genericArguments › [items] › typeIdentifier
    • concreteGenericInterfaces › [items] › genericClassIdentifier
    • concreteGenericInterfaces › [items] › identifier
    • customFiles
    • customFiles › [items]
    • customFiles › [items] › customCode
    • customFiles › [items] › customCode › [items]
    • customFiles › [items] › customCode › [items] › code
    • customFiles › [items] › customCode › [items] › templateRefs
    • customFiles › [items] › customCode › [items] › templateRefs › [items]
    • customFiles › [items] › customCode › [items] › templateRefs › [items] › placeholder
    • customFiles › [items] › customCode › [items] › templateRefs › [items] › typeIdentifier
    • customFiles › [items] › customImports
    • customFiles › [items] › customImports › [items]
    • customFiles › [items] › customImports › [items] › path
    • customFiles › [items] › customImports › [items] › types
    • customFiles › [items] › customImports › [items] › types › [items]
    • customFiles › [items] › fileName
    • customFiles › [items] › identifier
    • customFiles › [items] › name
    • customFiles › [items] › path
    • dictionaryTypes
    • dictionaryTypes › [items]
    • dictionaryTypes › [items] › keyPrimitiveType
    • dictionaryTypes › [items] › keyTypeIdentifier
    • dictionaryTypes › [items] › typeIdentifier
    • dictionaryTypes › [items] › valuePrimitiveType
    • dictionaryTypes › [items] › valueTypeIdentifier
    • dryRun
    • enums
    • enums › [items]
    • enums › [items] › comment
    • enums › [items] › fileName
    • enums › [items] › members
    • enums › [items] › members › [items]
    • enums › [items] › members › [items] › name
    • enums › [items] › members › [items] › stringValue
    • enums › [items] › members › [items] › value
    • enums › [items] › name
    • enums › [items] › path
    • enums › [items] › typeIdentifier
    • initialize
    • interfaces
    • interfaces › [items]
    • interfaces › [items] › comment
    • interfaces › [items] › customCode
    • interfaces › [items] › customCode › [items]
    • interfaces › [items] › customImports
    • interfaces › [items] › customImports › [items]
    • interfaces › [items] › decorators
    • interfaces › [items] › decorators › [items]
    • interfaces › [items] › fileName
    • interfaces › [items] › genericArguments
    • interfaces › [items] › genericArguments › [items]
    • interfaces › [items] › interfaceTypeIdentifiers
    • interfaces › [items] › interfaceTypeIdentifiers › [items]
    • interfaces › [items] › name
    • interfaces › [items] › path
    • interfaces › [items] › properties
    • interfaces › [items] › properties › [items]
    • interfaces › [items] › typeIdentifier
    • language
    • outputPath
    • packageName
    • skipExisting
    • typeScriptOptions
    • typeScriptOptions › relativeImportExtension

    No output schema is recorded for this tool in either release.

    Exact JSON from the published snapshots

    Loads the exact recorded definitions of this tool from both releases. The full snapshots are linked under Evidence and provenance.

    Link to this tool
  2. generate_from_recipeAddedAuthorityFAIL

    What changed

    • New tool generate_from_recipe, declared with unknown effect.

    Why it could matter

    • Valyd could not determine this tool’s effect from its declared interface, so its authority is not known.

    What to verify

    • Read the tool’s documentation and schema before allowing agents to use it.
    Declared effect
    — → unknown

    Input schema

    PropertyPrevious (1.4.2)Current (1.5.0)Change
    (schema root)not presentobject, additionalProperties=false, oneOf (2)
    • Added
    dryRunnot presentbooleanoptional
    • Added
    outputPathnot presentstringoptional
    • Added
    recipenot presentobject, additionalProperties=falseoptional
    • Added
    recipe › arrayTypesnot presentarray | nulloptional
    • Added
    recipe › arrayTypes › [items]not presentobject
    • Added
    recipe › classesnot presentarray | nulloptional
    • Added
    recipe › classes › [items]not presentobject
    • Added
    recipe › concreteGenericClassesnot presentarray | nulloptional
    • Added
    recipe › concreteGenericClasses › [items]not presentobject
    • Added
    recipe › concreteGenericInterfacesnot presentarray | nulloptional
    • Added
    recipe › concreteGenericInterfaces › [items]not presentobject
    • Added
    recipe › customFilesnot presentarray | nulloptional
    • Added
    recipe › customFiles › [items]not presentobject
    • Added
    recipe › dictionaryTypesnot presentarray | nulloptional
    • Added
    recipe › dictionaryTypes › [items]not presentobject
    • Added
    recipe › dryRunnot presentbooleanoptional
    • Added
    recipe › enumsnot presentarray | nulloptional
    • Added
    recipe › enums › [items]not presentobject
    • Added
    recipe › initializenot presentboolean | nulloptional
    • Added
    recipe › inputsnot presentobjectoptional
    • Added
    recipe › instancesnot presentarrayoptional
    • Added
    recipe › instances › [items]not presentobject
    • Added
    recipe › interfacesnot presentarray | nulloptional
    • Added
    recipe › interfaces › [items]not presentobject
    • Added
    recipe › languagenot presentstring, enum (11)required
    • Added
    recipe › outputPathnot presentstringoptional
    • Added
    recipe › packageNamenot presentstring | nulloptional
    • Added
    recipe › recipeVersionnot presentinteger, const=1required
    • Added
    recipe › skipEnumMembersValidationnot presentboolean | nulloptional
    • Added
    recipe › skipExistingnot presentbooleanoptional
    • Added
    recipe › templatesnot presentobjectoptional
    • Added
    recipe › typeScriptOptionsnot presentobject | null, additionalProperties=falseoptional
    • Added
    recipe › typeScriptOptions › relativeImportExtensionnot presentstring, enum (2)optional
    • Added
    recipeFilePathnot presentstringoptional
    • Added
    skipExistingnot presentbooleanoptional
    • Added

    No output schema is recorded for this tool in either release.

    Exact JSON from the published snapshots

    Loads the exact recorded definitions of this tool from both releases. The full snapshots are linked under Evidence and provenance.

    Link to this tool
  3. load_spec_from_fileModifiedDescriptionINFO

    What changed

    • load_spec_from_file: description changed.

    Why it could matter

    • Models choose and call tools partly from their descriptions.

    What to verify

    • Spot-check that agents still select this tool as intended.
    Declared effect
    unknown → unknown
    Description
    PreviousLoad code generation spec from a JSON file - Perfect for complex architectures and reusable templates! Instead of constructing large JSON specs in memory, load them from version-controlled .json files. All the same functionality as generate_code (outputPath, skipExisting, dryRun) but with zero memory overhead. Benefits: - Drastically reduced AI context usage (just pass file path!) - Version control your architecture patterns - Reusable templates across projects - Supports complex multi-file generations without context bloat Usage: 1. Create a .json file with your spec (same structure as generate_code) 2. Call this tool with the file path 3. Optionally override outputPath, skipExisting, or dryRun Example spec file (user-system.json): { "language": "typescript", "classes": [{"name": "User", ...}], "interfaces": [{...}] } Then call: load_spec_from_file({specFilePath: "specs/user-system.json", outputPath: "src"})
    CurrentRead an existing generate_code JSON payload from a local file and run the same generation flow. Use generate_from_recipe for compact field maps and reusable JSON templates. outputPath, skipExisting, and dryRun arguments override values in the file.

    Input schema

    Input schema unchanged.

    5 unchanged entries
    • (schema root)
    • dryRun
    • outputPath
    • skipExisting
    • specFilePath

    No output schema is recorded for this tool in either release.

    Exact JSON from the published snapshots

    Loads the exact recorded definitions of this tool from both releases. The full snapshots are linked under Evidence and provenance.

    Link to this tool
5 tools with no recorded change
  • generate_graphql
  • generate_openapi
  • generate_protobuf
  • generate_sql
  • metaengine_initialize

Evidence and provenance

Static findings
FAIL from Modelara’s automated analysis of the two declared interfaces. A policy outcome, not a security rating or a runtime test.
Human review
Pending human review. No reviewer decision is recorded for this comparison.
Published evidence
Part of Valyd’s published data generation listed in valyd-data-source.json. Published records are not rewritten.
Show provenance and exact files
Comparison
metaengine/1.4.2~1.5.0The published comparison identifier.
Analyzer
modelara v0.1.8Policy version not recorded.Analyzed Nov 3, 2026, 4:14 AM UTC.
Distribution
npm
Previous release
@metaengine/mcp-server@1.4.27 tools · published by the registry Aug 13, 2026, 2:05 PM UTCArtifact integritysha512-st9jVJeDLO6IM57PAKMMPQl2A7x1zI2T4ZDHz+wuaUPpaMlSFJMYZysTQiuTwpAZsfC9OTGnfXvj/CU9UvIqZg==Interface fingerprintsha256:d76c8e59b4d16487af153372eb4cb2dbe24761fa3cae01875a8582f7cf576422Exact interface snapshot (JSON)
Current release
@metaengine/mcp-server@1.5.08 tools · published by the registry Sep 15, 2026, 6:24 PM UTCArtifact integritysha512-yntTRl2igzYFBe9gWKrBcjwbnL4El1OTMac0wlK2EuJnMiv+elpNm5i2pyuL9yO0WJHUa+e8vE+KqXKGrTbNRQ==Interface fingerprintsha256:5cc01d82846a9b82a9d10f6e7c14c0a14d81982b72bbe75c5d4e36ddd2877475Exact interface snapshot (JSON)

The integrity value or digest identifies the exact artifact that was inspected; it does not show that the package is safe. The interface fingerprint identifies the declared tools and schemas Modelara recorded for that release.

MODELARA ANALYSIS OUTPUT

Interface findings

Analyzed with Modelara v0.1.8 · Nov 3, 2026

Policy failures

1 finding
  • generate_from_recipeFAILAdded

    New capability with unknown effect; the effect is unknown, so Modelara cannot establish that it is read-only

    Authority
    —UNKNOWN

Requires review

1 finding
  • generate_codeREVIEWChanged

    Input schema changed

    Show details
    • input property added: skipEnumMembersValidation
    Authority
    UNKNOWNUNKNOWN
    Authority unchanged

Informational

2 findings
  • generate_codeINFOChanged

    Description changed

    Authority
    UNKNOWNUNKNOWN
    Authority unchanged
  • load_spec_from_fileINFOChanged

    Description changed

    Authority
    UNKNOWNUNKNOWN
    Authority unchanged
What do these results mean?
PASS
No policy-significant interface change detected.
REVIEW
Interface changes require inspection.
FAIL
A policy-significant change was detected.
INVALID
The comparison could not be evaluated reliably.
← Back to MetaEngine MCP release history