Macroforge MCP Server

# Your First Macro Let's create a class that uses Macroforge's derive macros to automatically generate useful methods. ## Creating a Class with Derive Macros Start by creating a simple `User` class. We'll use the `@derive` decorator to automatically generate methods. Before (Your Code) ``` /** @derive(Debug, Clone, PartialEq) */ export class User { name: string; age: number; email: string; constructor(name: string, age: number, email: string) { this.name = name; this.age = age; this.email = email; } } ``` After (Generated) ``` export class User { name: string; age: number; email: string; constructor(name: string, age: number, email: string) { this.name = name; this.age = age; this.email = email; } static toString(value: User): string { return userToString(value); } static clone(value: User): User { return userClone(value); } static equals(a: User, b: User): boolean { return userEquals(a, b); } } export function userToString(value: User): string { const parts: string[] = []; parts.push('name: ' + value.name); parts.push('age: ' + value.age); parts.push('email: ' + value.email); return 'User { ' + parts.join(', ') + ' }'; } export function userClone(value: User): User { const cloned = Object.create(Object.getPrototypeOf(value)); cloned.name = value.name; cloned.age = value.age; cloned.email = value.email; return cloned; } export function userEquals(a: User, b: User): boolean { if (a === b) return true; return a.name === b.name && a.age === b.age && a.email === b.email; } ``` ## Using the Generated Methods TypeScript ``` const user = new User("Alice", 30, "alice@example.com"); // Debug: toString() console.log(user.toString()); // Output: User { name: Alice, age: 30, email: alice@example.com } // Clone: clone() const copy = user.clone(); console.log(copy.name); // "Alice" // Eq: equals() console.log(user.equals(copy)); // true const different = new User("Bob", 25, "bob@example.com"); console.log(user.equals(different)); // false ``` ## Customizing Behavior You can customize how macros work using field-level decorators. For example, with the Debug macro: Before (Your Code) ``` /** @derive(Debug) */ export class User { /** @debug({ rename: "userId" }) */ id: number; name: string; /** @debug({ skip: true }) */ password: string; constructor(id: number, name: string, password: string) { this.id = id; this.name = name; this.password = password; } } ``` After (Generated) ``` export class User { id: number; name: string; password: string; constructor(id: number, name: string, password: string) { this.id = id; this.name = name; this.password = password; } static toString(value: User): string { return userToString(value); } } export function userToString(value: User): string { const parts: string[] = []; parts.push('userId: ' + value.id); parts.push('name: ' + value.name); return 'User { ' + parts.join(', ') + ' }'; } ``` TypeScript ``` const user = new User(42, "Alice", "secret123"); console.log(user.toString()); // Output: User { userId: 42, name: Alice } // Note: 'id' is renamed to 'userId', 'password' is skipped ``` Field-level decorators Field-level decorators let you control exactly how each field is handled by the macro. ## Next Steps * [Learn how macros work under the hood](../../docs/concepts) * [Explore all Debug options](../../docs/builtin-macros/debug) * [Create your own custom macros](../../docs/custom-macros)