@macroforge/mcp-server 0.1.42 → 0.1.50

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

@@ -1,58 +1,66 @@
-## Match Expressions: `{#match}`
+## Match Expressions: `{#match}`
 
 Use `match` for exhaustive pattern matching:
 
-```rust
-enum Visibility { Public, Private, Protected }
-let visibility = Visibility::Public;
-
-let code = ts_template! {
-    {#match visibility}
-        {:case Visibility::Public}
-            public
-        {:case Visibility::Private}
-            private
-        {:case Visibility::Protected}
-            protected
-    {/match}
-    field: string;
+Rust
+
+```
+enum Visibility { Public, Private, Protected }
+let visibility = Visibility::Public;
+
+let code = ts_template! {
+    {#match visibility}
+        {:case Visibility::Public}
+            public
+        {:case Visibility::Private}
+            private
+        {:case Visibility::Protected}
+            protected
+    {/match}
+    field: string;
 };
 ```
 
 **Generates:**
 
-```typescript
-public field: string;
+TypeScript
+
+```
+public field: string;
 ```
 
 ### Match with Value Extraction
 
-```rust
-let result: Result<i32, &str> = Ok(42);
+Rust
 
-let code = ts_template! {
-    const value = {#match result}
-        {:case Ok(val)}
-            @{val}
-        {:case Err(msg)}
-            throw new Error("@{msg}")
-    {/match};
+```
+let result: Result<i32, &str> = Ok(42);
+
+let code = ts_template! {
+    const value = {#match result}
+        {:case Ok(val)}
+            @{val}
+        {:case Err(msg)}
+            throw new Error("@{msg}")
+    {/match};
 };
 ```
 
 ### Match with Wildcard
 
-```rust
-let count = 5;
-
-let code = ts_template! {
-    {#match count}
-        {:case 0}
-            console.log("none");
-        {:case 1}
-            console.log("one");
-        {:case _}
-            console.log("many");
-    {/match}
+Rust
+
+```
+let count = 5;
+
+let code = ts_template! {
+    {#match count}
+        {:case 0}
+            console.log("none");
+        {:case 1}
+            console.log("one");
+        {:case _}
+            console.log("many");
+    {/match}
 };
 ```

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

@@ -1,15 +1,10 @@
 # Template Syntax
 
-*The `macroforge_ts_quote` crate provides template-based code generation for TypeScript. The `ts_template!` macro uses 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
 
-| `ts_template!` 
-            | Any TypeScript code 
-            | General code generation 
-        
-
-        
-            | `body!` 
-            | Class body members 
-            | Methods and properties
+| Macro          | Output              | Use Case                |
+| -------------- | ------------------- | ----------------------- |
+| `ts_template!` | Any TypeScript code | General code generation |
+| `body!`        | Class body members  | Methods and properties  |

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

@@ -0,0 +1,39 @@
+## Pattern Matching: `{#if let}`
+
+Use `if let` for pattern matching on `Option`, `Result`, or other Rust enums:
+
+Rust
+
+```
+let maybe_name: Option<&str> = Some("Alice");
+
+let code = ts_template! {
+    {#if let Some(name) = maybe_name}
+        console.log("Hello, @{name}!");
+    {:else}
+        console.log("Hello, anonymous!");
+    {/if}
+};
+```
+
+**Generates:**
+
+TypeScript
+
+```
+console.log("Hello, Alice!");
+```
+
+This is useful when working with optional values from your IR:
+
+Rust
+
+```
+let code = ts_template! {
+    {#if let Some(default_val) = field.default_value}
+        this.@{field.name} = @{default_val};
+    {:else}
+        this.@{field.name} = undefined;
+    {/if}
+};
+```

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

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

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

@@ -1,87 +1,22 @@
-## Side Effects: `{$do}`
+## Side Effects: `{$do}`
 
 Execute an expression for its side effects without producing output. This is commonly used with mutable variables:
 
-```rust
-let code = ts_template! {
-    {$let mut results: Vec<String> = Vec::new()}
-    {#for field in fields}
-        {$do results.push(format!("this.{}", field))}
-    {/for}
-    return [@{results.join(", ")}];
-};
-```
-
-Common uses for `&#123;$do&#125;`:
-
-- Incrementing counters: `&#123;$do i += 1&#125;`
-
-    - Building collections: `&#123;$do vec.push(item)&#125;`
-
-    - Setting flags: `&#123;$do found = true&#125;`
-
-    - Any mutating operation
-
-<h2 id="typescript-injection">
-    TsStream Injection: `&#123;$typescript&#125;`
-</h2>
-
-Inject another TsStream into your template, preserving both its source code and runtime patches (like imports added via `add_import()`):
-
-```rust
-// Create a helper method with its own import
-let mut helper = body! {
-    validateEmail(email: string): boolean {
-        return Result.ok(true);
-    }
-};
-helper.add_import("Result", "macroforge/utils");
+Rust
 
-// Inject the helper into the main template
-let result = body! {
-    {$typescript helper}
-
-    process(data: Record<string, unknown>): void {
-        // ...
-    }
-};
-// result now includes helper's source AND its Result import
 ```
-
-This is essential for composing multiple macro outputs while preserving imports and patches:
-
-```rust
-let extra_methods = if include_validation {
-    Some(body! {
-        validate(): boolean { return true; }
-    })
-} else {
-    None
+let code = ts_template! {
+    {$let mut results: Vec<String> = Vec::new()}
+    {#for field in fields}
+        {$do results.push(format!("this.{}", field))}
+    {/for}
+    return [@{results.join(", ")}];
 };
-
-body! {
-    mainMethod(): void {}
-
-    {#if let Some(methods) = extra_methods}
-        {$typescript methods}
-    {/if}
-}
-```
-
-## Escape Syntax
-
-If you need a literal `@&#123;` in your output (not interpolation), use `@@&#123;`:
-
-```rust
-ts_template! {
-    // This outputs a literal @{foo}
-    const example = "Use @@{foo} for templates";
-}
 ```
 
-**Generates:**
+Common uses for `{$do}`:
 
-```typescript
-// This outputs a literal @{foo}
-const example = "Use @{foo} for templates";
-```
+*   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-textexpr.md

@@ -0,0 +1,36 @@
+## String Interpolation: `"text @{expr}"`
+
+Interpolation works automatically inside string literals - no `format!()` needed:
+
+Rust
+
+```
+let name = "World";
+let count = 42;
+
+let code = ts_template! {
+    console.log("Hello @{name}!");
+    console.log("Count: @{count}, doubled: @{count * 2}");
+};
+```
+
+**Generates:**
+
+TypeScript
+
+```
+console.log("Hello World!");
+console.log("Count: 42, doubled: 84");
+```
+
+This also works with method calls and complex expressions:
+
+Rust
+
+```
+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,61 +1,69 @@
-## TsStream Injection: `{$typescript}`
+## TsStream Injection: `{$typescript}`
 
 Inject another TsStream into your template, preserving both its source code and runtime patches (like imports added via `add_import()`):
 
-```rust
-// Create a helper method with its own import
-let mut helper = body! {
-    validateEmail(email: string): boolean {
-        return Result.ok(true);
-    }
+Rust
+
+```
+// Create a helper method with its own import
+let mut helper = body! {
+    validateEmail(email: string): boolean {
+        return Result.ok(true);
+    }
 };
-helper.add_import("Result", "macroforge/utils");
+helper.add_import("Result", "macroforge/utils");
 
-// Inject the helper into the main template
-let result = body! {
-    {$typescript helper}
+// Inject the helper into the main template
+let result = body! {
+    {$typescript helper}
 
-    process(data: Record<string, unknown>): void {
-        // ...
-    }
+    process(data: Record<string, unknown>): void {
+        // ...
+    }
 };
-// result now includes helper's source AND its Result import
+// result now includes helper's source AND its Result import
 ```
 
 This is essential for composing multiple macro outputs while preserving imports and patches:
 
-```rust
-let extra_methods = if include_validation {
-    Some(body! {
-        validate(): boolean { return true; }
-    })
-} else {
-    None
+Rust
+
+```
+let extra_methods = if include_validation {
+    Some(body! {
+        validate(): boolean { return true; }
+    })
+} else {
+    None
 };
 
-body! {
-    mainMethod(): void {}
+body! {
+    mainMethod(): void {}
 
-    {#if let Some(methods) = extra_methods}
-        {$typescript methods}
-    {/if}
+    {#if let Some(methods) = extra_methods}
+        {$typescript methods}
+    {/if}
 }
 ```
 
 ## Escape Syntax
 
-If you need a literal `@&#123;` in your output (not interpolation), use `@@&#123;`:
+If you need a literal `@{` in your output (not interpolation), use `@@{`:
 
-```rust
-ts_template! {
-    // This outputs a literal @{foo}
-    const example = "Use @@{foo} for templates";
+Rust
+
+```
+ts_template! {
+    // This outputs a literal @{foo}
+    const example = "Use @@{foo} for templates";
 }
 ```
 
 **Generates:**
 
-```typescript
-// This outputs a literal @{foo}
-const example = "Use @{foo} for templates";
+TypeScript
+
+```
+// This outputs a literal @{foo}
+const example = "Use @{foo} for templates";
 ```

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

@@ -1,37 +1,43 @@
-## While Loops: `{#while}`
+## While Loops: `{#while}`
 
 Use `while` for loops that need to continue until a condition is false:
 
-```rust
-let items = get_items();
-let mut idx = 0;
+Rust
 
-let code = ts_template! {
-    {$let mut i = 0}
-    {#while i < items.len()}
-        console.log("Item @{i}");
-        {$do i += 1}
-    {/while}
+```
+let items = get_items();
+let mut idx = 0;
+
+let code = ts_template! {
+    {$let mut i = 0}
+    {#while i < items.len()}
+        console.log("Item @{i}");
+        {$do i += 1}
+    {/while}
 };
 ```
 
 ### While-Let Pattern Matching
 
-Use `while let` for iterating with pattern matching, similar to `if let`:
+Use `while let` for iterating with pattern matching, similar to `if let`:
+
+Rust
 
-```rust
-let mut items = vec!["a", "b", "c"].into_iter();
+```
+let mut items = vec!["a", "b", "c"].into_iter();
 
-let code = ts_template! {
-    {#while let Some(item) = items.next()}
-        console.log("@{item}");
-    {/while}
+let code = ts_template! {
+    {#while let Some(item) = items.next()}
+        console.log("@{item}");
+    {/while}
 };
 ```
 
 **Generates:**
 
-```typescript
+TypeScript
+
+```
 console.log("a");
 console.log("b");
 console.log("c");
@@ -39,10 +45,12 @@ console.log("c");
 
 This is especially useful when working with iterators or consuming optional values:
 
-```rust
-let code = ts_template! {
-    {#while let Some(next_field) = remaining_fields.pop()}
-        result.@{next_field.name} = this.@{next_field.name};
-    {/while}
+Rust
+
+```
+let code = ts_template! {
+    {#while let Some(next_field) = remaining_fields.pop()}
+        result.@{next_field.name} = this.@{next_field.name};
+    {/while}
 };
 ```