@macroforge/mcp-server 0.1.37 → 0.1.39

package/docs/builtin-macros/hash.md

@@ -8,18 +8,11 @@ objects to be used as keys in hash-based collections.
 
 | Type | Generated Code | Description |
 |------|----------------|-------------|
-| Class | `hashCode(): number` | Instance method computing hash from all fields |
-| Enum | `hashCodeEnumName(value: EnumName): number` | Standalone function hashing by enum value |
-| Interface | `hashCodeInterfaceName(value: InterfaceName): number` | Standalone function computing hash |
-| Type Alias | `hashCodeTypeName(value: TypeName): number` | Standalone function computing hash |
+| Class | `classNameHashCode(value)` + `static hashCode(value)` | Standalone function + static wrapper method |
+| Enum | `enumNameHashCode(value: EnumName): number` | Standalone function hashing by enum value |
+| Interface | `interfaceNameHashCode(value: InterfaceName): number` | Standalone function computing hash |
+| Type Alias | `typeNameHashCode(value: TypeName): number` | Standalone function computing hash |
 
-## Configuration
-
-The `functionNamingStyle` option in `macroforge.json` controls naming:
-- `"prefix"` (default): Prefixes with type name (e.g., `myTypeHashCode`)
-- `"suffix"`: Suffixes with type name (e.g., `hashCodeMyType`)
-- `"generic"`: Uses TypeScript generics (e.g., `hashCode<T extends MyType>`)
-- `"namespace"`: Legacy namespace wrapping
 
 ## Hash Algorithm
 
@@ -55,23 +48,97 @@ The `@hash` decorator supports:
 
 ## Example
 
+```typescript before
+/** @derive(Hash, PartialEq) */
+class User {
+    id: number;
+    name: string;
+
+    /** @hash({ skip: true }) */
+    cachedScore: number;
+}
+```
+
+```typescript after
+class User {
+    id: number;
+    name: string;
+
+    cachedScore: number;
+
+    static hashCode(value: User): number {
+        return userHashCode(value);
+    }
+
+    static equals(a: User, b: User): boolean {
+        return userEquals(a, b);
+    }
+}
+
+export function userHashCode(value: User): number {
+    let hash = 17;
+    hash =
+        (hash * 31 +
+            (Number.isInteger(value.id)
+                ? value.id | 0
+                : value.id
+                      .toString()
+                      .split('')
+                      .reduce((h, c) => (h * 31 + c.charCodeAt(0)) | 0, 0))) |
+        0;
+    hash =
+        (hash * 31 +
+            (value.name ?? '').split('').reduce((h, c) => (h * 31 + c.charCodeAt(0)) | 0, 0)) |
+        0;
+    return hash;
+}
+
+export function userEquals(a: User, b: User): boolean {
+    if (a === b) return true;
+    return a.id === b.id && a.name === b.name && a.cachedScore === b.cachedScore;
+}
+```
+
+Generated output:
+
 ```typescript
-@derive(Hash, PartialEq)
 class User {
     id: number;
     name: string;
 
-    @hash(skip)  // Cached value shouldn't affect hash
     cachedScore: number;
+
+    static hashCode(value: User): number {
+        return userHashCode(value);
+    }
+
+    static equals(a: User, b: User): boolean {
+        return userEquals(a, b);
+    }
 }
 
-// Generated:
-// hashCode(): number {
-//     let hash = 17;
-//     hash = (hash * 31 + (Number.isInteger(this.id) ? this.id | 0 : ...)) | 0;
-//     hash = (hash * 31 + (this.name ?? '').split('').reduce(...)) | 0;
-//     return hash;
-// }
+export function userHashCode(value: User): number {
+    let hash = 17;
+    hash =
+        (hash * 31 +
+            (Number.isInteger(value.id)
+                ? value.id | 0
+                : value.id
+                      .toString()
+                      .split('')
+                      .reduce((h, c) => (h * 31 + c.charCodeAt(0)) | 0, 0))) |
+        0;
+    hash =
+        (hash * 31 +
+            (value.name ?? '').split('').reduce((h, c) => (h * 31 + c.charCodeAt(0)) | 0, 0)) |
+        0;
+    return hash;
+}
+
+export function userEquals(a: User, b: User): boolean {
+    if (a === b) return true;
+    return a.id === b.id && a.name === b.name && a.cachedScore === b.cachedScore;
+}
 ```
 
 ## Hash Contract

package/docs/builtin-macros/macros-overview.md

@@ -16,57 +16,57 @@
  Built-in macros don't require imports. Just use them with `@derive`:
  ```
 /** @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;
-  }
-}
+  }
+}
 ``` ## Interface Support
  All built-in macros work with interfaces. For interfaces, methods are generated as functions in a namespace with the same name, using `self` as the first parameter:
  ```
 /** @derive(Debug, Clone, PartialEq) */
-interface Point {
+interface Point {
   x: number;
   y: number;
-}
+}
 
 // Generated namespace:
-// namespace Point {
-//   export function toString(self: Point): string { ... }
-//   export function clone(self: Point): Point { ... }
-//   export function equals(self: Point, other: Point): boolean { ... }
-//   export function hashCode(self: Point): number { ... }
-// }
+// namespace Point {
+//   export function toString(self: Point): string { ... }
+//   export function clone(self: Point): Point { ... }
+//   export function equals(self: Point, other: Point): boolean { ... }
+//   export function hashCode(self: Point): number { ... }
+// }
 
-const point: Point = { x: 10, y: 20 };
+const point: Point = { x: 10, y: 20 };
 
 // Use the namespace functions
-console.log(Point.toString(point));     // "Point { x: 10, y: 20 }"
-const copy = Point.clone(point);        // { x: 10, y: 20 }
+console.log(Point.toString(point));     // "Point { x: 10, y: 20 }"
+const copy = Point.clone(point);        // { x: 10, y: 20 }
 console.log(Point.equals(point, copy)); // true
 ``` ## Enum Support
  All built-in macros work with enums. For enums, methods are generated as functions in a namespace with the same name:
  ```
 /** @derive(Debug, Clone, PartialEq, Serialize, Deserialize) */
-enum Status {
+enum Status {
   Active = "active",
   Inactive = "inactive",
   Pending = "pending",
-}
+}
 
 // Generated namespace:
-// namespace Status {
-//   export function toString(value: Status): string { ... }
-//   export function clone(value: Status): Status { ... }
-//   export function equals(a: Status, b: Status): boolean { ... }
-//   export function hashCode(value: Status): number { ... }
-//   export function toJSON(value: Status): string | number { ... }
-//   export function fromJSON(data: unknown): Status { ... }
-// }
+// namespace Status {
+//   export function toString(value: Status): string { ... }
+//   export function clone(value: Status): Status { ... }
+//   export function equals(a: Status, b: Status): boolean { ... }
+//   export function hashCode(value: Status): number { ... }
+//   export function toJSON(value: Status): string | number { ... }
+//   export function fromJSON(data: unknown): Status { ... }
+// }
 
 // Use the namespace functions
 console.log(Status.toString(Status.Active));     // "Status.Active"
@@ -77,24 +77,24 @@ const parsed = Status.fromJSON("active");        // Status.Active
  All built-in macros work with type aliases. For object type aliases, field-aware methods are generated in a namespace:
  ```
 /** @derive(Debug, Clone, PartialEq, Serialize, Deserialize) */
-type Point = {
+type Point = {
   x: number;
   y: number;
-};
+};
 
 // Generated namespace:
-// namespace Point {
-//   export function toString(value: Point): string { ... }
-//   export function clone(value: Point): Point { ... }
-//   export function equals(a: Point, b: Point): boolean { ... }
-//   export function hashCode(value: Point): number { ... }
-//   export function toJSON(value: Point): Record<string, unknown> { ... }
-//   export function fromJSON(data: unknown): Point { ... }
-// }
+// namespace Point &#123;
+//   export function toString(value: Point): string &#123; ... &#125;
+//   export function clone(value: Point): Point &#123; ... &#125;
+//   export function equals(a: Point, b: Point): boolean &#123; ... &#125;
+//   export function hashCode(value: Point): number &#123; ... &#125;
+//   export function toJSON(value: Point): Record&#x3C;string, unknown> &#123; ... &#125;
+//   export function fromJSON(data: unknown): Point &#123; ... &#125;
+// &#125;
 
-const point: Point = { x: 10, y: 20 };
-console.log(Point.toString(point));     // "Point { x: 10, y: 20 }"
-const copy = Point.clone(point);        // { x: 10, y: 20 }
+const point: Point = &#123; x: 10, y: 20 &#125;;
+console.log(Point.toString(point));     // "Point &#123; x: 10, y: 20 &#125;"
+const copy = Point.clone(point);        // &#123; x: 10, y: 20 &#125;
 console.log(Point.equals(point, copy)); // true
 ``` Union type aliases also work, using JSON-based implementations:
  ```
@@ -102,7 +102,7 @@ console.log(Point.equals(point, copy)); // true
 type ApiStatus = "loading" | "success" | "error";
 
 const status: ApiStatus = "success";
-console.log(ApiStatus.toString(status)); // "ApiStatus(\"success\")"
+console.log(ApiStatus.toString(status)); // "ApiStatus(\\"success\\")"
 console.log(ApiStatus.equals("success", "success")); // true
 ``` ## Combining Macros
  All macros can be used together. They don't conflict and each generates independent methods:
@@ -111,7 +111,7 @@ const user = new User("Alice", 30);
 
 // Debug
 console.log(user.toString());
-// "User { name: Alice, age: 30 }"
+// "User &#123; name: Alice, age: 30 &#125;"
 
 // Clone
 const copy = user.clone();

package/docs/builtin-macros/ord.md

@@ -8,29 +8,22 @@ compared with a guaranteed ordering relationship.
 
 | Type | Generated Code | Description |
 |------|----------------|-------------|
-| Class | `compareTo(other): number` | Instance method returning -1, 0, or 1 |
-| Enum | `compareEnumName(a: EnumName, b: EnumName): number` | Standalone function comparing enum values |
-| Interface | `compareInterfaceName(a: InterfaceName, b: InterfaceName): number` | Standalone function comparing fields |
-| Type Alias | `compareTypeName(a: TypeName, b: TypeName): number` | Standalone function with type-appropriate comparison |
+| Class | `classNameCompare(a, b)` + `static compareTo(a, b)` | Standalone function + static wrapper method |
+| Enum | `enumNameCompare(a: EnumName, b: EnumName): number` | Standalone function comparing enum values |
+| Interface | `interfaceNameCompare(a: InterfaceName, b: InterfaceName): number` | Standalone function comparing fields |
+| Type Alias | `typeNameCompare(a: TypeName, b: TypeName): number` | Standalone function with type-appropriate comparison |
 
-## Configuration
-
-The `functionNamingStyle` option in `macroforge.json` controls naming:
-- `"prefix"` (default): Prefixes with type name (e.g., `myTypeCompare`)
-- `"suffix"`: Suffixes with type name (e.g., `compareMyType`)
-- `"generic"`: Uses TypeScript generics (e.g., `compare<T extends MyType>`)
-- `"namespace"`: Legacy namespace wrapping
 
 ## Return Values
 
 Unlike `PartialOrd`, `Ord` provides **total ordering** - every pair of values
 can be compared:
 
-- **-1**: `this` is less than `other`
-- **0**: `this` is equal to `other`
-- **1**: `this` is greater than `other`
+- **-1**: `a` is less than `b`
+- **0**: `a` is equal to `b`
+- **1**: `a` is greater than `b`
 
-The method **never returns null** - all values must be comparable.
+The function **never returns null** - all values must be comparable.
 
 ## Comparison Strategy
 
@@ -60,29 +53,61 @@ The `@ord` decorator supports:
 
 ## Example
 
+```typescript before
+/** @derive(Ord) */
+class Version {
+    major: number;
+    minor: number;
+    patch: number;
+}
+```
+
+```typescript after
+class Version {
+    major: number;
+    minor: number;
+    patch: number;
+
+    static compareTo(a: Version, b: Version): number {
+        return versionCompare(a, b);
+    }
+}
+
+export function versionCompare(a: Version, b: Version): number {
+    if (a === b) return 0;
+    const cmp0 = a.major < b.major ? -1 : a.major > b.major ? 1 : 0;
+    if (cmp0 !== 0) return cmp0;
+    const cmp1 = a.minor < b.minor ? -1 : a.minor > b.minor ? 1 : 0;
+    if (cmp1 !== 0) return cmp1;
+    const cmp2 = a.patch < b.patch ? -1 : a.patch > b.patch ? 1 : 0;
+    if (cmp2 !== 0) return cmp2;
+    return 0;
+}
+```
+
+Generated output:
+
 ```typescript
-@derive(Ord)
 class Version {
     major: number;
     minor: number;
     patch: number;
+
+    static compareTo(a: Version, b: Version): number {
+        return versionCompare(a, b);
+    }
 }
 
-// Generated:
-// compareTo(other: Version): number {
-//     if (this === other) return 0;
-//     const typedOther = other;
-//     const cmp0 = this.major < typedOther.major ? -1 : this.major > typedOther.major ? 1 : 0;
-//     if (cmp0 !== 0) return cmp0;
-//     const cmp1 = this.minor < typedOther.minor ? -1 : ...;
-//     if (cmp1 !== 0) return cmp1;
-//     const cmp2 = this.patch < typedOther.patch ? -1 : ...;
-//     if (cmp2 !== 0) return cmp2;
-//     return 0;
-// }
-
-// Usage:
-versions.sort((a, b) => a.compareTo(b));
+export function versionCompare(a: Version, b: Version): number {
+    if (a === b) return 0;
+    const cmp0 = a.major < b.major ? -1 : a.major > b.major ? 1 : 0;
+    if (cmp0 !== 0) return cmp0;
+    const cmp1 = a.minor < b.minor ? -1 : a.minor > b.minor ? 1 : 0;
+    if (cmp1 !== 0) return cmp1;
+    const cmp2 = a.patch < b.patch ? -1 : a.patch > b.patch ? 1 : 0;
+    if (cmp2 !== 0) return cmp2;
+    return 0;
+}
 ```
 
 ## Ord vs PartialOrd