developer-tools Static interface comparison

MetaEngine MCP

1.4.1 1.4.2

REVIEWPending human review

1 schema change requires review.No new authority detected.

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 → 7
Added0
Removed0
Schema changes1
Input schema changes1
Output schema changes0
Unclassified schema changes0
Description changes1
New write authority0
New destructive authority0
New unknown authority0
AnalysisREVIEW

INTERFACE DIFF

What changed, tool by tool

Classification from the recorded findings · definitions from the published snapshots

1 tool with recorded changes

  1. generate_codeModifiedSchemaDescriptionREVIEWINFO

    What changed

    • generate_code — Schema change: input property added: typeScriptOptions.
    • generate_code — Schema change: input property classes changed: items {"properties":{"bas… → {"properties":{"bas….
    • generate_code — Schema change: input property dictionaryTypes changed: items {"properties":{"key… → {"properties":{"key….
    • 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. --- ## 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.
    CurrentSemantic 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.

    Input schema

    PropertyPrevious (1.4.1)Current (1.4.2)Change
    classes › [items] › constructorParameters › [items] › templateRefsnot presentarrayoptional
    • Added
    classes › [items] › constructorParameters › [items] › templateRefs › [items]not presentobject
    • Added
    classes › [items] › constructorParameters › [items] › templateRefs › [items] › placeholdernot presentstringoptional
    • Added
    classes › [items] › constructorParameters › [items] › templateRefs › [items] › typeIdentifiernot presentstringoptional
    • Added
    dictionaryTypes › [items] › keyTypestringoptionalnot present
    • Removed
    typeScriptOptionsnot presentobject, additionalProperties=falseoptional
    • Added
    typeScriptOptions › relativeImportExtensionnot presentstring, enum (2)optional
    • Added
    144 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] › 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

    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
6 tools with no recorded change
  • generate_graphql
  • generate_openapi
  • generate_protobuf
  • generate_sql
  • load_spec_from_file
  • metaengine_initialize

Evidence and provenance

Static findings
REVIEW 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.1~1.4.2The 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.17 tools · published by the registry Jul 7, 2026, 9:57 AM UTCArtifact integritysha512-DCkjzMRE7f58fnzYp1BniyULD975MkL3bfSKwhFGuUQdNC2Wt1Z1z8QX0JkQCC2VWamhrM2w1PRrJHpEv/dEyQ==Interface fingerprintsha256:e45a5e7b9b286fd2b1390d836a0e0ea36cf322a5e57e9f4da44814022bbf1a78Exact interface snapshot (JSON)
Current 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)

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

Requires review

1 finding
  • generate_codeREVIEWChanged

    Input schema changed

    Show details
    • input property added: typeScriptOptions
    • input property classes changed: items {"properties":{"bas… → {"properties":{"bas…
    • input property dictionaryTypes changed: items {"properties":{"key… → {"properties":{"key…
    Authority
    UNKNOWNUNKNOWN
    Authority unchanged

Informational

1 finding
  • generate_codeINFOChanged

    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