@macroforge/mcp-server 0.1.65 → 0.1.66

package/docs/custom-macros/rust-setup.md

@@ -1,12 +1,13 @@
 # Rust Setup
 
-Create a new Rust crate that will contain your custom macros. This crate compiles to a native Node.js addon.
+Create a new Rust crate that will contain your custom macros. This crate compiles to a native
+Node.js addon.
 
 ## Prerequisites
 
-*   Rust toolchain (1.88 or later)
-*   Node.js 24 or later
-*   NAPI-RS CLI: `cargo install macroforge_ts`
+- Rust toolchain (1.88 or later)
+- Node.js 24 or later
+- NAPI-RS CLI: `cargo install macroforge_ts`
 
 ## Create the Project
 
@@ -25,7 +26,7 @@ napi new --platform --name my-macros
 
 Update your `Cargo.toml` with the required dependencies:
 
-Cargo.toml 
+Cargo.toml
 
 ```
 [package]
@@ -51,7 +52,7 @@ strip = true
 
 ## Create build.rs
 
-build.rs 
+build.rs
 
 ```
 fn main() {
@@ -61,7 +62,7 @@ fn main() {
 
 ## Create src/lib.rs
 
-src/lib.rs 
+src/lib.rs
 
 ```
 use macroforge_ts::macros::{ts_macro_derive, body};
@@ -98,7 +99,7 @@ pub fn derive_json(mut input: TsStream) -> Result<TsStream, MacroforgeErr
 
 ## Create package.json
 
-package.json 
+package.json
 
 ```
 {
@@ -147,5 +148,5 @@ For cross-platform builds, use GitHub Actions with the NAPI-RS CI template.
 
 ## Next Steps
 
-*   [Learn the #\[ts\_macro\_derive\] attribute](../../docs/custom-macros/ts-macro-derive)
-*   [Master the template syntax](../../docs/custom-macros/ts-quote)
+- [Learn the #\[ts\_macro\_derive\] attribute](../../docs/custom-macros/ts-macro-derive)
+- [Master the template syntax](../../docs/custom-macros/ts-quote)

package/docs/custom-macros/ts-macro-derive/accessing-field-data.md

@@ -59,4 +59,5 @@ struct DecoratorIR {
 
 Note
 
-To check for decorators, iterate through `field.decorators` and check `decorator.name`. For parsing options, you can write helper functions like the built-in macros do.
+To check for decorators, iterate through `field.decorators` and check `decorator.name`. For parsing
+options, you can write helper functions like the built-in macros do.

package/docs/custom-macros/ts-macro-derive/adding-imports.md

@@ -21,4 +21,5 @@ Ok(output)
 
 Note
 
-Imports are automatically deduplicated. If the same import already exists in the file, it won't be added again.
+Imports are automatically deduplicated. If the same import already exists in the file, it won't be
+added again.

package/docs/custom-macros/ts-macro-derive/attribute-options.md

@@ -42,4 +42,4 @@ pub fn derive_debug(...)
 
 Note
 
-Declared attributes become available as `@attributeName({ options })` decorators in TypeScript.
+Declared attributes become available as `@attributeName({ options })` decorators in TypeScript.

package/docs/custom-macros/ts-macro-derive/complete-example.md

@@ -50,4 +50,4 @@ pub fn derive_validate(mut input: TsStream) -> Result<TsStream, Macroforg
 
 ## Next Steps
 
-*   [Learn the template syntax](../../docs/custom-macros/ts-quote)
+- [Learn the template syntax](../../docs/custom-macros/ts-quote)

package/docs/custom-macros/ts-macro-derive/deriveinput-structure.md

@@ -60,4 +60,4 @@ impl DataTypeAlias {
     fn as_union(&self) -> Option<&[TypeMember]>;
     fn as_object(&self) -> Option<&[InterfaceFieldIR]>;
 }
-```
+```

package/docs/custom-macros/ts-macro-derive/function-signature.md

@@ -9,4 +9,4 @@ pub fn my_macro(mut input: TsStream) -> Result<TsStream, MacroforgeError>
 | Parameter                           | Description                                             |
 | ----------------------------------- | ------------------------------------------------------- |
 | `input: TsStream`                   | Token stream containing the class/interface AST         |
-| `Result<TsStream, MacroforgeError>` | Returns generated code or an error with source location |
+| `Result<TsStream, MacroforgeError>` | Returns generated code or an error with source location |

package/docs/custom-macros/ts-macro-derive/overview.md

@@ -1,6 +1,7 @@
 # ts\_macro\_derive
 
-The `#[ts_macro_derive]` attribute is a Rust procedural macro that registers your function as a Macroforge derive macro.
+The `#[ts_macro_derive]` attribute is a Rust procedural macro that registers your function as a
+Macroforge derive macro.
 
 ## Basic Syntax
 
@@ -14,4 +15,4 @@ use macroforge_ts::ts_syn::{TsStream, MacroforgeError};
 pub fn my_macro(mut input: TsStream) -> Result<TsStream, MacroforgeError> {
     // Macro implementation
 }
-```
+```

package/docs/custom-macros/ts-macro-derive/parsing-input.md

@@ -26,4 +26,4 @@ pub fn my_macro(mut input: TsStream) -> Result<TsStream, MacroforgeError>
         }
     }
 }
-```
+```

package/docs/custom-macros/ts-macro-derive/returning-errors.md

@@ -20,4 +20,4 @@ pub fn class_only(mut input: TsStream) -> Result<TsStream, MacroforgeErro
         )),
     }
 }
-```
+```

package/docs/custom-macros/ts-macro-derive.md

@@ -1,6 +1,7 @@
 # ts\_macro\_derive
 
-The `#[ts_macro_derive]` attribute is a Rust procedural macro that registers your function as a Macroforge derive macro.
+The `#[ts_macro_derive]` attribute is a Rust procedural macro that registers your function as a
+Macroforge derive macro.
 
 ## Basic Syntax
 
@@ -230,7 +231,8 @@ struct DecoratorIR {
 
 Note
 
-To check for decorators, iterate through `field.decorators` and check `decorator.name`. For parsing options, you can write helper functions like the built-in macros do.
+To check for decorators, iterate through `field.decorators` and check `decorator.name`. For parsing
+options, you can write helper functions like the built-in macros do.
 
 ## Adding Imports
 
@@ -255,7 +257,8 @@ Ok(output)
 
 Note
 
-Imports are automatically deduplicated. If the same import already exists in the file, it won't be added again.
+Imports are automatically deduplicated. If the same import already exists in the file, it won't be
+added again.
 
 ## Returning Errors
 
@@ -333,4 +336,4 @@ pub fn derive_validate(mut input: TsStream) -> Result<TsStream, Macroforg
 
 ## Next Steps
 
-*   [Learn the template syntax](../../docs/custom-macros/ts-quote)
+- [Learn the template syntax](../../docs/custom-macros/ts-quote)

package/docs/custom-macros/ts-quote/backtick-template-literals.md

@@ -1,6 +1,7 @@
 ## Backtick Template Literals: `"'^...^'"`
 
-For JavaScript template literals (backtick strings), use the `'^...^'` syntax. This outputs actual backticks and passes through `${"${}"}` for JS interpolation:
+For JavaScript template literals (backtick strings), use the `'^...^'` syntax. This outputs actual
+backticks and passes through `${"${}"}` for JS interpolation:
 
 Rust
 
@@ -20,7 +21,8 @@ TypeScript
 const html = `<div>${content}</div>`;
 ```
 
-You can mix Rust `@{}` interpolation (evaluated at macro expansion time) with JS `${"${}"}` interpolation (evaluated at runtime):
+You can mix Rust `@{}` interpolation (evaluated at macro expansion time) with JS `${"${}"}`
+interpolation (evaluated at runtime):
 
 Rust
 
@@ -38,4 +40,4 @@ TypeScript
 
 ```
 `Hello ${this.name}, you are a User`
-```
+```

package/docs/custom-macros/ts-quote/comments-and.md

@@ -1,6 +1,7 @@
 ## Comments: `{> "..." <}` and `{>> "..." <<}`
 
-Since Rust's tokenizer strips whitespace before macros see them, use string literals to preserve exact spacing in comments:
+Since Rust's tokenizer strips whitespace before macros see them, use string literals to preserve
+exact spacing in comments:
 
 ### Block Comments
 
@@ -76,4 +77,4 @@ TypeScript
 ```
 /** @param {number} userId - The user ID */
 function getUser(userId: number) {}
-```
+```

package/docs/custom-macros/ts-quote/complete-example-json-derive-macro.md

@@ -68,14 +68,15 @@ pub fn derive_json_macro(input: TsStream) -> MacroResult {
 
 ## How It Works
 
-1.  **Compile-Time:** The template is parsed during macro expansion
-2.  **String Building:** Generates Rust code that builds a TypeScript string at runtime
-3.  **SWC Parsing:** The generated string is parsed with SWC to produce a typed AST
-4.  **Result:** Returns `Stmt` that can be used in `MacroResult` patches
+1. **Compile-Time:** The template is parsed during macro expansion
+2. **String Building:** Generates Rust code that builds a TypeScript string at runtime
+3. **SWC Parsing:** The generated string is parsed with SWC to produce a typed AST
+4. **Result:** Returns `Stmt` that can be used in `MacroResult` patches
 
 ## Return Type
 
-`ts_template!` returns a `Result<Stmt, TsSynError>` by default. The macro automatically unwraps and provides helpful error messages showing the generated TypeScript code if parsing fails:
+`ts_template!` returns a `Result<Stmt, TsSynError>` by default. The macro automatically unwraps and
+provides helpful error messages showing the generated TypeScript code if parsing fails:
 
 Text
 
@@ -92,8 +93,8 @@ This shows you exactly what was generated, making debugging easy!
 
 You can mix template syntax with regular TypeScript. Braces `{}` are recognized as either:
 
-*   **Template tags** if they start with `#`, `$`, `:`, or `/`
-*   **Regular TypeScript blocks** otherwise
+- **Template tags** if they start with `#`, `$`, `:`, or `/`
+- **Regular TypeScript blocks** otherwise
 
 Rust
 
@@ -120,7 +121,7 @@ ts_template! {
 
 ## Best Practices
 
-1.  Use `ts_template!` for complex code generation with loops/conditions
-2.  Use `ts_quote!` for simple, static statements
-3.  Keep templates readable - extract complex logic into variables
-4.  Don't nest templates too deeply - split into helper functions
+1. Use `ts_template!` for complex code generation with loops/conditions
+2. Use `ts_quote!` for simple, static statements
+3. Keep templates readable - extract complex logic into variables
+4. Don't nest templates too deeply - split into helper functions

package/docs/custom-macros/ts-quote/conditionals-ifif.md

@@ -49,4 +49,4 @@ let code = ts_template! {
         console.log("Other level");
     {/if}
 };
-```
+```

package/docs/custom-macros/ts-quote/identifier-concatenation-content.md

@@ -1,6 +1,7 @@
-## Identifier Concatenation: ` content `
+## Identifier Concatenation: `content`
 
-When you need to build identifiers dynamically (like `getUser`, `setName`), use the ident block syntax. Everything inside ` ` is concatenated without spaces:
+When you need to build identifiers dynamically (like `getUser`, `setName`), use the ident block
+syntax. Everything inside `` is concatenated without spaces:
 
 Rust
 
@@ -24,7 +25,8 @@ function getUser() {
 }
 ```
 
-Without ident blocks, `@{}` always adds a space after for readability. Use ` ` when you explicitly want concatenation:
+Without ident blocks, `@{}` always adds a space after for readability. Use `` when you explicitly
+want concatenation:
 
 Rust
 

package/docs/custom-macros/ts-quote/interpolation-expr.md

@@ -17,7 +17,7 @@ let code = ts_template! {
 
 ```typescript
 User.prototype.toString = function () {
-    return "User instance";
+    return 'User instance';
 };
 ```
 
@@ -25,7 +25,8 @@ User.prototype.toString = function () {
     Identifier Concatenation: `{| content |}`
 </h2>
 
-When you need to build identifiers dynamically (like `getUser`, `setName`), use the ident block syntax. Everything inside `&#123;| |&#125;` is concatenated without spaces:
+When you need to build identifiers dynamically (like `getUser`, `setName`), use the ident block
+syntax. Everything inside `&#123;| |&#125;` is concatenated without spaces:
 
 ```rust
 let field_name = "User";
@@ -45,7 +46,8 @@ function getUser() {
 }
 ```
 
-Without ident blocks, `@&#123;&#125;` always adds a space after for readability. Use `&#123;| |&#125;` when you explicitly want concatenation:
+Without ident blocks, `@&#123;&#125;` always adds a space after for readability. Use
+`&#123;| |&#125;` when you explicitly want concatenation:
 
 ```rust
 let name = "Status";
@@ -71,7 +73,8 @@ ts_template! { @{entity}_@{action} }  // → "user_create"
     `&#123;>> "..." <<&#125;`
 </h2>
 
-Since Rust's tokenizer strips whitespace before macros see them, use string literals to preserve exact spacing in comments:
+Since Rust's tokenizer strips whitespace before macros see them, use string literals to preserve
+exact spacing in comments:
 
 ### Block Comments
 
@@ -111,7 +114,7 @@ let code = ts_template! {
 /** @param {string} name - The user's name */
 /** @returns {string} A greeting message */
 function greet(name: string): string {
-    return "Hello, " + name;
+    return 'Hello, ' + name;
 }
 ```
 
@@ -141,7 +144,8 @@ function getUser(userId: number) {}
     String Interpolation: `"text @&#123;expr&#125;"`
 </h2>
 
-Interpolation works automatically inside string literals - no <code >format!()</code > needed:
+Interpolation works automatically inside string literals - no
+<code >format!()</code > needed:
 
 ```rust
 let name = "World";
@@ -156,8 +160,8 @@ let code = ts_template! {
 **Generates:**
 
 ```typescript
-console.log("Hello World!");
-console.log("Count: 42, doubled: 84");
+console.log('Hello World!');
+console.log('Count: 42, doubled: 84');
 ```
 
 This also works with method calls and complex expressions:
@@ -174,7 +178,9 @@ let code = ts_template! {
     Backtick Template Literals: `"'^...^'"`
 </h2>
 
-For JavaScript template literals (backtick strings), use the <code >'^...^'</code > syntax. This outputs actual backticks and passes through `${"${}"}` for JS interpolation:
+For JavaScript template literals (backtick strings), use the
+<code >'^...^'</code > syntax. This outputs actual backticks and passes through `${"${}"}` for JS
+interpolation:
 
 ```rust
 let tag_name = "div";
@@ -188,7 +194,8 @@ let code = ts_template! {
 
 <CodeBlock code={"const html = `${content}`;"} lang="typescript" />
 
-You can mix Rust `@&#123;&#125;` interpolation (evaluated at macro expansion time) with JS `${"${}"}` interpolation (evaluated at runtime):
+You can mix Rust `@&#123;&#125;` interpolation (evaluated at macro expansion time) with JS
+`${"${}"}` interpolation (evaluated at runtime):
 
 ```rust
 let class_name = "User";
@@ -272,7 +279,7 @@ let code = ts_template! {
 **Generates:**
 
 ```typescript
-console.log("Hello, Alice!");
+console.log('Hello, Alice!');
 ```
 
 This is useful when working with optional values from your IR:

package/docs/custom-macros/ts-quote/iteration-for.md

@@ -65,4 +65,4 @@ ts_template! {
         };
     {/for}
 }
-```
+```

package/docs/custom-macros/ts-quote/local-constants-let.md

@@ -33,4 +33,4 @@ let code = ts_template! {
     {/for}
     console.log("Total: @{count}");
 };
-```
+```

package/docs/custom-macros/ts-quote/match-expressions-match.md

@@ -63,4 +63,4 @@ let code = ts_template! {
             console.log("many");
     {/match}
 };
-```
+```

package/docs/custom-macros/ts-quote/overview.md

@@ -1,10 +1,12 @@
 # Template Syntax
 
-The `macroforge_ts_quote` crate provides template-based code generation for TypeScript. The `ts_template!` macro uses Svelte + Rust-inspired syntax for control flow and interpolation, making it easy to generate complex TypeScript code.
+The `macroforge_ts_quote` crate provides template-based code generation for TypeScript. The
+`ts_template!` macro uses Svelte + Rust-inspired syntax for control flow and interpolation, making
+it easy to generate complex TypeScript code.
 
 ## Available Macros
 
 | Macro          | Output              | Use Case                |
 | -------------- | ------------------- | ----------------------- |
 | `ts_template!` | Any TypeScript code | General code generation |
-| `body!`        | Class body members  | Methods and properties  |
+| `body!`        | Class body members  | Methods and properties  |

package/docs/custom-macros/ts-quote/pattern-matching-if-let.md

@@ -17,7 +17,7 @@ let code = ts_template! {
 **Generates:**
 
 ```typescript
-console.log("Hello, Alice!");
+console.log('Hello, Alice!');
 ```
 
 This is useful when working with optional values from your IR:
@@ -30,4 +30,4 @@ let code = ts_template! {
         this.@{field.name} = undefined;
     {/if}
 };
-```
+```

package/docs/custom-macros/ts-quote/pattern-matching-iflet.md

@@ -36,4 +36,4 @@ let code = ts_template! {
         this.@{field.name} = undefined;
     {/if}
 };
-```
+```

package/docs/custom-macros/ts-quote/quick-reference.md

@@ -1,28 +1,29 @@
 ## Quick Reference
 
-| Syntax                                                         | Description                                                                   |
-| -------------------------------------------------------------- | ----------------------------------------------------------------------------- |
-| `@{expr}`                                                      | Interpolate a Rust expression (adds space after)                              |
+| Syntax                                                         | Description                                                                             |
+| -------------------------------------------------------------- | --------------------------------------------------------------------------------------- |
+| `@{expr}`                                                      | Interpolate a Rust expression (adds space after)                                        |
 | `{| content |}`                                      | Ident block: concatenates without spaces (e.g., `{|get@{name}|}` → `getUser`) |
-| `{> "comment" <}`                                              | Block comment: outputs `/* comment */` (string preserves whitespace)          |
-| `{>> "doc" <<}`                                                | Doc comment: outputs `/** doc */` (string preserves whitespace)               |
-| `@@{`                                                          | Escape for literal `@{` (e.g., `"@@{foo}"` → `@{foo}`)                        |
-| `"text @{expr}"`                                               | String interpolation (auto-detected)                                          |
-| `"'^template ${js}^'"`                                         | JS backtick template literal (outputs `` `template ${js}` ``)                 |
-| `{#if cond}...{/if}`                                           | Conditional block                                                             |
-| `{#if cond}...{:else}...{/if}`                                 | Conditional with else                                                         |
-| `{#if a}...{:else if                     b}...{:else}...{/if}` | Full if/else-if/else chain                                                    |
-| `{#if let pattern = expr}...{/if}`                             | Pattern matching if-let                                                       |
-| `{#match expr}{:case                     pattern}...{/match}`  | Match expression with case arms                                               |
-| `{#for item in list}...{/for}`                                 | Iterate over a collection                                                     |
-| `{#while cond}...{/while}`                                     | While loop                                                                    |
-| `{#while let pattern = expr}...{/while}`                       | While-let pattern matching loop                                               |
-| `{$let name = expr}`                                           | Define a local constant                                                       |
-| `{$let mut name = expr}`                                       | Define a mutable local variable                                               |
-| `{$do expr}`                                                   | Execute a side-effectful expression                                           |
-| `{$typescript stream}`                                         | Inject a TsStream, preserving its source and runtime\_patches (imports)       |
-
-**Note:** A single `@` not followed by `{` passes through unchanged (e.g., `email@domain.com` works as expected).
+| `{> "comment" <}`                                              | Block comment: outputs `/* comment */` (string preserves whitespace)                    |
+| `{>> "doc" <<}`                                                | Doc comment: outputs `/** doc */` (string preserves whitespace)                         |
+| `@@{`                                                          | Escape for literal `@{` (e.g., `"@@{foo}"` → `@{foo}`)                                  |
+| `"text @{expr}"`                                               | String interpolation (auto-detected)                                                    |
+| `"'^template ${js}^'"`                                         | JS backtick template literal (outputs `` `template ${js}` ``)                           |
+| `{#if cond}...{/if}`                                           | Conditional block                                                                       |
+| `{#if cond}...{:else}...{/if}`                                 | Conditional with else                                                                   |
+| `{#if a}...{:else if                     b}...{:else}...{/if}` | Full if/else-if/else chain                                                              |
+| `{#if let pattern = expr}...{/if}`                             | Pattern matching if-let                                                                 |
+| `{#match expr}{:case                     pattern}...{/match}`  | Match expression with case arms                                                         |
+| `{#for item in list}...{/for}`                                 | Iterate over a collection                                                               |
+| `{#while cond}...{/while}`                                     | While loop                                                                              |
+| `{#while let pattern = expr}...{/while}`                       | While-let pattern matching loop                                                         |
+| `{$let name = expr}`                                           | Define a local constant                                                                 |
+| `{$let mut name = expr}`                                       | Define a mutable local variable                                                         |
+| `{$do expr}`                                                   | Execute a side-effectful expression                                                     |
+| `{$typescript stream}`                                         | Inject a TsStream, preserving its source and runtime\_patches (imports)                 |
+
+**Note:** A single `@` not followed by `{` passes through unchanged (e.g., `email@domain.com` works
+as expected).
 
 ## Interpolation: `@{expr}`
 
@@ -49,4 +50,4 @@ TypeScript
 User.prototype.toString = function () {
   return "User instance";
 };
-```
+```

package/docs/custom-macros/ts-quote/side-effects-do.md

@@ -1,6 +1,7 @@
 ## Side Effects: `{$do}`
 
-Execute an expression for its side effects without producing output. This is commonly used with mutable variables:
+Execute an expression for its side effects without producing output. This is commonly used with
+mutable variables:
 
 Rust
 
@@ -16,7 +17,7 @@ let code = ts_template! {
 
 Common uses for `{$do}`:
 
-*   Incrementing counters: `{$do i += 1}`
-*   Building collections: `{$do vec.push(item)}`
-*   Setting flags: `{$do found = true}`
-*   Any mutating operation
+- Incrementing counters: `{$do i += 1}`
+- Building collections: `{$do vec.push(item)}`
+- Setting flags: `{$do found = true}`
+- Any mutating operation

package/docs/custom-macros/ts-quote/string-interpolation-text-expr.md

@@ -15,8 +15,8 @@ let code = ts_template! {
 **Generates:**
 
 ```typescript
-console.log("Hello World!");
-console.log("Count: 42, doubled: 84");
+console.log('Hello World!');
+console.log('Count: 42, doubled: 84');
 ```
 
 This also works with method calls and complex expressions:
@@ -27,4 +27,4 @@ let field = "username";
 let code = ts_template! {
     throw new Error("Invalid @{field.to_uppercase()}");
 };
-```
+```

package/docs/custom-macros/ts-quote/string-interpolation-textexpr.md

@@ -33,4 +33,4 @@ let field = "username";
 let code = ts_template! {
     throw new Error("Invalid @{field.to_uppercase()}");
 };
-```
+```

package/docs/custom-macros/ts-quote/tsstream-injection-typescript.md

@@ -1,6 +1,7 @@
 ## TsStream Injection: `{$typescript}`
 
-Inject another TsStream into your template, preserving both its source code and runtime patches (like imports added via `add_import()`):
+Inject another TsStream into your template, preserving both its source code and runtime patches
+(like imports added via `add_import()`):
 
 Rust
 
@@ -66,4 +67,4 @@ TypeScript
 ```
 // This outputs a literal @{foo}
 const example = "Use @{foo} for templates";
-```
+```

package/docs/custom-macros/ts-quote/while-loops-while.md

@@ -53,4 +53,4 @@ let code = ts_template! {
         result.@{next_field.name} = this.@{next_field.name};
     {/while}
 };
-```
+```