@macroforge/mcp-server 0.1.36 → 0.1.38

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:
-- `"suffix"` (default): Suffixes with type name (e.g., `hashCodeMyType`)
-- `"prefix"`: Prefixes with type name (e.g., `myTypeHashCode`)
-- `"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/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:
-- `"suffix"` (default): Suffixes with type name (e.g., `compareMyType`)
-- `"prefix"`: Prefixes with type name (e.g., `myTypeCompare`)
-- `"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