@macroforge/mcp-server 0.1.38 → 0.1.39

package/docs/getting-started/first-macro.md

@@ -69,7 +69,7 @@ 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 }
+// Output: User { name: Alice, age: 30, email: alice@example.com }
 
 // Clone: clone()
 const copy = user.clone();
@@ -130,7 +130,7 @@ export function userToString(value: User): string {
 ``` ```
 const user = new User(42, "Alice", "secret123");
 console.log(user.toString());
-// Output: User { userId: 42, name: Alice }
+// 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)

package/docs/getting-started/installation.md

@@ -15,15 +15,15 @@ pnpm add macroforge
  The simplest way to use Macroforge is with the built-in derive macros. Add a `@derive` comment decorator to your class:
  ```
 /** @derive(Debug, Clone, PartialEq) */
-class User {
+class User {
   name: string;
   age: number;
 
-  constructor(name: string, age: number) {
+  constructor(name: string, age: number) {
     this.name = name;
     this.age = age;
-  }
-}
+  }
+}
 
 // After macro expansion, User has:
 // - toString(): string              (from Debug)
@@ -32,15 +32,15 @@ class User {
 ``` ## IDE Integration
  For the best development experience, add the TypeScript plugin to your `tsconfig.json`:
  ```
-{
-  "compilerOptions": {
+{
+  "compilerOptions": {
     "plugins": [
-      {
+      {
         "name": "@macroforge/typescript-plugin"
-      }
+      }
     ]
-  }
-}
+  }
+}
 ``` This enables features like:
  - Accurate error positions in your source code
  - Autocompletion for generated methods
@@ -49,16 +49,16 @@ class User {
  If you're using Vite, add the plugin to your config for automatic macro expansion during build:
  ```
 import macroforge from "@macroforge/vite-plugin";
-import { defineConfig } from "vite";
+import { defineConfig } from "vite";
 
-export default defineConfig({
+export default defineConfig({
   plugins: [
-    macroforge({
+    macroforge({
       generateTypes: true,
       typesOutputDir: ".macroforge/types"
-    })
+    })
   ]
-});
+});
 ``` ## Next Steps
  Now that you have Macroforge installed, learn how to use it:
  - [Create your first macro](../docs/getting-started/first-macro)

package/docs/integration/cli.md

@@ -15,7 +15,7 @@ cargo build --release --bin macroforge
  ### macroforge expand
  Expands macros in a TypeScript file and outputs the transformed code.
  ```
-macroforge expand <input> [options]
+macroforge expand &#x3C;input> [options]
 ``` #### Arguments
  | Argument | Description |
 | --- | --- |
@@ -60,15 +60,15 @@ macroforge tsc -p tsconfig.build.json
  When expanding a file like this:
  ```
 /** @derive(Debug) */
-class User {
+class User &#123;
   name: string;
   age: number;
 
-  constructor(name: string, age: number) {
+  constructor(name: string, age: number) &#123;
     this.name = name;
     this.age = age;
-  }
-}
+  &#125;
+&#125;
 ``` The CLI outputs the expanded code with the generated methods:
  ```
 class User {
@@ -94,11 +94,11 @@ class User {
  Use `macroforge tsc` in your CI pipeline to type-check with macro expansion:
  ```
 # package.json
-{
-  "scripts": {
+&#123;
+  "scripts": &#123;
     "typecheck": "macroforge tsc"
-  }
-}
+  &#125;
+&#125;
 ``` ### Debugging Macro Output
  Use `macroforge expand` to inspect what code your macros generate:
  ```

package/docs/integration/configuration.md

@@ -3,17 +3,17 @@
  ## Configuration File
  Create a `macroforge.json` file:
  ```
-{
+{
   "allowNativeMacros": true,
   "macroPackages": [],
   "keepDecorators": false,
-  "limits": {
+  "limits": {
     "maxExecutionTimeMs": 5000,
     "maxMemoryBytes": 104857600,
     "maxOutputSize": 10485760,
     "maxDiagnostics": 100
-  }
-}
+  }
+}
 ``` ## Options Reference
  ### allowNativeMacros
  | Type | `boolean` |
@@ -24,12 +24,12 @@
 | Default | `[]` |
  List of npm packages that provide macros. Macroforge will look for macros in these packages.
  ```
-{
+{
   "macroPackages": [
     "@my-org/custom-macros",
     "community-macros"
   ]
-}
+}
 ``` ### keepDecorators
  | Type | `boolean` |
 | Default | `false` |
@@ -37,8 +37,8 @@
  ### limits
  Configure resource limits for macro expansion:
  ```
-{
-  "limits": {
+{
+  "limits": {
     // Maximum time for a single macro expansion (ms)
     "maxExecutionTimeMs": 5000,
 
@@ -50,18 +50,18 @@
 
     // Maximum number of diagnostics per file
     "maxDiagnostics": 100
-  }
-}
+  }
+}
 ``` ## Macro Runtime Overrides
  Override settings for specific macros:
  ```
-{
-  "macroRuntimeOverrides": {
-    "@my-org/macros": {
+{
+  "macroRuntimeOverrides": {
+    "@my-org/macros": {
       "maxExecutionTimeMs": 10000
-    }
-  }
-}
+    }
+  }
+}
 ```  **Warning Be careful when increasing limits, as this could allow malicious macros to consume excessive resources. ## Environment Variables
  Some settings can be overridden with environment variables:
  | Variable | Description |

package/docs/integration/mcp-server.md

@@ -12,14 +12,14 @@ claude mcp add -t stdio -s [scope] macroforge -- npx -y @macroforge/mcp-server
  ## Claude Desktop
  In the Settings > Developer section, click on Edit Config. It will open the folder with a `claude_desktop_config.json` file in it. Edit the file to include the following configuration:
  ```
-{
-    "mcpServers": {
-        "macroforge": {
+{
+    "mcpServers": {
+        "macroforge": {
             "command": "npx",
             "args": ["-y", "@macroforge/mcp-server"]
-        }
-    }
-}
+        }
+    }
+}
 ``` ## Codex CLI
  Add the following to your `config.toml` (which defaults to `~/.codex/config.toml`, but refer to [the configuration documentation](https://github.com/openai/codex/blob/main/docs/config.md) for more advanced setups):
  ```

package/docs/integration/svelte-preprocessor.md

@@ -7,52 +7,51 @@ npm install -D @macroforge/svelte-preprocessor
  Add the preprocessor to your `svelte.config.js`:
  ```
 import adapter from '@sveltejs/adapter-auto';
-import { vitePreprocess } from '@sveltejs/vite-plugin-svelte';
-import { macroforgePreprocess } from '@macroforge/svelte-preprocessor';
+import { vitePreprocess } from '@sveltejs/vite-plugin-svelte';
+import { macroforgePreprocess } from '@macroforge/svelte-preprocessor';
 
-/** @type {import('@sveltejs/kit').Config} */
-const config = {
+/** @type {import('@sveltejs/kit').Config} */
+const config = {
   preprocess: [
     macroforgePreprocess(),  // Expand macros FIRST
     vitePreprocess()          // Then handle TypeScript/CSS
   ],
 
-  kit: {
+  kit: {
     adapter: adapter()
-  }
-};
+  }
+};
 
 export default config;
 ```  **Warning Always place `macroforgePreprocess()` **before** other preprocessors like `vitePreprocess()`. This ensures macros are expanded before TypeScript compilation. ## Usage
  Use `@derive` decorators directly in your Svelte component scripts:
  ```
-**<script lang="ts">
+&#x3C;script lang="ts">
   /** @derive(Debug, Clone) */
-  class User {
+  class User &#123;
     name: string;
     email: string;
 
-    constructor(name: string, email: string) {
+    constructor(name: string, email: string) &#123;
       this.name = name;
       this.email = email;
-    }
-  }
+    &#125;
+  &#125;
 
   let user = new User("Alice", "alice@example.com");
   console.log(user.toString());  // Generated by Debug macro
-</script>
-
-User: {user.name}
+&#x3C;/script>
 
+&#x3C;p>User: &#123;user.name&#125;&#x3C;/p>
 ``` ## Options
  ```
-macroforgePreprocess({
+macroforgePreprocess(&#123;
   // Keep @derive decorators in output (for debugging)
   keepDecorators: false,
 
   // Process JavaScript files (not just TypeScript)
   processJavaScript: false
-})
+&#125;)
 ``` ### Option Reference
  | Option | Type | Default | Description |
 | --- | --- | --- | --- |
@@ -64,66 +63,66 @@ macroforgePreprocess({
  2. Checks for `@derive` decorators (skips files without them)
  3. Expands macros using the native Macroforge binary
  4. Returns the transformed code for Svelte compilation
-  **Tip Files without `@derive` decorators are passed through unchanged with zero overhead. ## SvelteKit Integration
+  ****Tip Files without `@derive` decorators are passed through unchanged with zero overhead. ## SvelteKit Integration
  For SvelteKit projects, you can use both the preprocessor (for `.svelte` files) and the Vite plugin (for standalone `.ts` files):
  ```
 // svelte.config.js
-import { macroforgePreprocess } from '@macroforge/svelte-preprocessor';
-import { vitePreprocess } from '@sveltejs/vite-plugin-svelte';
+import &#123; macroforgePreprocess &#125; from '@macroforge/svelte-preprocessor';
+import &#123; vitePreprocess &#125; from '@sveltejs/vite-plugin-svelte';
 
-export default {
+export default &#123;
   preprocess: [
     macroforgePreprocess(),
     vitePreprocess()
   ]
-};
+&#125;;
 ``` ```
 // vite.config.ts
 import macroforge from '@macroforge/vite-plugin';
-import { sveltekit } from '@sveltejs/kit/vite';
-import { defineConfig } from 'vite';
+import &#123; sveltekit &#125; from '@sveltejs/kit/vite';
+import &#123; defineConfig &#125; from 'vite';
 
-export default defineConfig({
+export default defineConfig(&#123;
   plugins: [
     macroforge(),  // For .ts files
     sveltekit()
   ]
-});
+&#125;);
 ``` ## Using with Vitest
  The preprocessor works seamlessly with Vitest for testing Svelte components:
  ```
 // vitest.config.ts
-import { defineConfig } from 'vitest/config';
-import { sveltekit } from '@sveltejs/kit/vite';
-import { svelteTesting } from '@testing-library/svelte/vite';
+import &#123; defineConfig &#125; from 'vitest/config';
+import &#123; sveltekit &#125; from '@sveltejs/kit/vite';
+import &#123; svelteTesting &#125; from '@testing-library/svelte/vite';
 import macroforge from '@macroforge/vite-plugin';
 
-export default defineConfig({
+export default defineConfig(&#123;
   plugins: [
     macroforge(),
     sveltekit(),
     svelteTesting()
   ],
-  test: {
+  test: &#123;
     environment: 'jsdom',
-    include: ['src/**/*.{test,spec}.{js,ts}']
-  }
-});
+    include: ['src/**/*.&#123;test,spec&#125;.&#123;js,ts&#125;']
+  &#125;
+&#125;);
 ``` ## Svelte 5 Runes Compatibility
  The preprocessor is fully compatible with Svelte 5 runes (`$state`, `$derived`, `$props`, etc.). Files using runes but without `@derive` decorators are skipped entirely.
  ```
-**<script lang="ts">
+&#x3C;script lang="ts">
   // Runes work normally
   let count = $state(0);
   let doubled = $derived(count * 2);
 
   // Macros expand correctly
   /** @derive(Debug) */
-  class Counter {
+  class Counter &#123;
     value: number;
-    constructor(value: number) {
+    constructor(value: number) &#123;
       this.value = value;
-    }
-  }
-</script>
-```
+    &#125;
+  &#125;
+&#x3C;/script>
+```**

package/docs/integration/typescript-plugin.md

@@ -6,32 +6,32 @@ npm install -D @macroforge/typescript-plugin
 ``` ## Configuration
  Add the plugin to your `tsconfig.json`:
  ```
-{
-  "compilerOptions": {
+{
+  "compilerOptions": {
     "plugins": [
-      {
+      {
         "name": "@macroforge/typescript-plugin"
-      }
+      }
     ]
-  }
-}
+  }
+}
 ``` ## VS Code Setup
  VS Code uses its own TypeScript version by default. To use the workspace version (which includes plugins):
  1. Open the Command Palette (`Cmd/Ctrl + Shift + P`)
  2. Search for "TypeScript: Select TypeScript Version"
  3. Choose "Use Workspace Version"
   **Tip Add this setting to your `.vscode/settings.json` to make it permanent: ```
-{
+{
   "typescript.tsdk": "node_modules/typescript/lib"
-}
+}
 ``` ## Features
  ### Error Reporting
  Errors in macro-generated code are reported at the `@derive` decorator position:
  ```
-/** @derive(Debug) */  // **<- Errors appear here
-class User {
+/** @derive(Debug) */  // &#x3C;- Errors appear here
+class User &#123;
   name: string;
-}
+&#125;
 ``` ### Completions
  The plugin provides completions for generated methods:
  ```
@@ -51,4 +51,5 @@ const copy = user.clone();
  ### Errors Not Showing
  If errors from macros aren't appearing:
  1. Make sure the Vite plugin is also installed (for source file watching)
- 2. Check that your file is saved (plugins process on save)
+ 2. Check that your file is saved (plugins process on save)
+**

package/docs/integration/vite-plugin.md

@@ -7,16 +7,16 @@ npm install -D @macroforge/vite-plugin
  Add the plugin to your `vite.config.ts`:
  ```
 import macroforge from "@macroforge/vite-plugin";
-import { defineConfig } from "vite";
+import { defineConfig } from "vite";
 
-export default defineConfig({
+export default defineConfig({
   plugins: [
     macroforge()
   ]
-});
+});
 ``` ## Options
  ```
-macroforge({
+macroforge({
   // Generate .d.ts files for expanded code
   generateTypes: true,
 
@@ -32,7 +32,7 @@ macroforge({
   // File patterns to process
   include: ["**/*.ts", "**/*.tsx"],
   exclude: ["node_modules/**"]
-})
+})
 ``` ### Option Reference
  | Option | Type | Default | Description |
 | --- | --- | --- | --- |
@@ -45,26 +45,26 @@ macroforge({
  ```
 import macroforge from "@macroforge/vite-plugin";
 import react from "@vitejs/plugin-react";
-import { defineConfig } from "vite";
+import { defineConfig } from "vite";
 
-export default defineConfig({
+export default defineConfig({
   plugins: [
     macroforge(),  // Before React plugin
     react()
   ]
-});
+});
 ``` ### SvelteKit
  ```
 import macroforge from "@macroforge/vite-plugin";
-import { sveltekit } from "@sveltejs/kit/vite";
-import { defineConfig } from "vite";
+import { sveltekit } from "@sveltejs/kit/vite";
+import { defineConfig } from "vite";
 
-export default defineConfig({
+export default defineConfig({
   plugins: [
     macroforge(),  // Before SvelteKit
     sveltekit()
   ]
-});
+});
 ``` > **Note:** Always place the Macroforge plugin before other framework plugins to ensure macros are expanded first. ## Development Server
  During development, the plugin:
  - Watches for file changes

package/docs/language-servers/zed.md

@@ -23,7 +23,7 @@ cd crates/extensions/svelte-macroforge
  Alternatively, symlink the extension to your Zed extensions directory:
  ```
 # macOS
-ln -s /path/to/macroforge-ts/crates/extensions/vtsls-macroforge ~/Library/Application\ Support/Zed/extensions/installed/vtsls-macroforge
+ln -s /path/to/macroforge-ts/crates/extensions/vtsls-macroforge ~/Library/Application\\ Support/Zed/extensions/installed/vtsls-macroforge
 
 # Linux
 ln -s /path/to/macroforge-ts/crates/extensions/vtsls-macroforge ~/.config/zed/extensions/installed/vtsls-macroforge

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@macroforge/mcp-server",
-  "version": "0.1.38",
+  "version": "0.1.39",
   "description": "MCP server for Macroforge documentation and code analysis",
   "type": "module",
   "main": "dist/index.js",
@@ -29,7 +29,7 @@
     "typescript": "^5.7.0"
   },
   "peerDependencies": {
-    "macroforge": "^0.1.38"
+    "macroforge": "^0.1.39"
   },
   "peerDependenciesMeta": {
     "macroforge": {