atmx-cli 0.1.93

package/dist/generators/model-generator.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateModels = generateModels;
+const utils_1 = require("./utils");
+function generateModels(multiIr) {
+    const sections = [
+        `// GENERATED CODE – DO NOT EDIT.\n/* eslint-disable @typescript-eslint/no-explicit-any */\n`
+    ];
+    // 1. Generate flat exports (NO namespaces)
+    for (const [ns, ir] of Object.entries(multiIr)) {
+        const pascalNs = (0, utils_1.pascalCase)(ns);
+        const enumsList = Array.isArray(ir.enums) ? ir.enums : Object.values(ir.enums || {});
+        const modelsList = Array.isArray(ir.models) ? ir.models : Object.values(ir.models || {});
+        enumsList.forEach((en) => sections.push(generateEnum(en, pascalNs)));
+        modelsList.forEach((model) => sections.push(generateInterface(model, pascalNs)));
+    }
+    // 2. Generate nested Mappers object
+    sections.push(generateMappers(multiIr));
+    return sections.join('\n');
+}
+function generateEnum(en, ns) {
+    const name = `${ns}${(0, utils_1.pascalCase)(en.name)}`;
+    const values = en.values.map(v => `  ${(0, utils_1.pascalCase)(v)}: "${v}"`).join(',\n');
+    return `
+export const ${name} = {
+${values}
+} as const;
+
+export type ${name} = typeof ${name}[keyof typeof ${name}];
+`;
+}
+function generateInterface(model, ns) {
+    const name = `${ns}${(0, utils_1.pascalCase)(model.name)}`;
+    const fields = model.fields.map(f => {
+        const type = (0, utils_1.mapTypeToTs)(f.typeRef, ns); // ✅ pass namespace
+        return `  ${(0, utils_1.camelCase)(f.name)}${f.isOptional ? '?' : ''}: ${type};`;
+    }).join('\n');
+    return `
+export interface ${name} {
+${fields}
+}
+`;
+}
+function generateMappers(multiIr) {
+    const lines = [`export const Mappers: Record<string, any> = {`];
+    for (const [ns, ir] of Object.entries(multiIr)) {
+        const camelNs = (0, utils_1.camelCase)(ns);
+        const pascalNs = (0, utils_1.pascalCase)(ns);
+        lines.push(`  ${camelNs}: {`);
+        const modelsList = Array.isArray(ir.models) ? ir.models : Object.values(ir.models || {});
+        modelsList.forEach((model) => {
+            const name = (0, utils_1.pascalCase)(model.name);
+            const fullType = `${pascalNs}${name}`; // no namespace now
+            lines.push(`    ${name}: {\n      fromJson: (json: any): ${fullType} => ({`);
+            model.fields.forEach((f) => {
+                lines.push(`        ${(0, utils_1.camelCase)(f.name)}: ${generateJsonLogic(f.typeRef, `json["${f.name}"]`, f.isOptional, 'fromJson', camelNs)},`);
+            });
+            lines.push(`      }),\n      toJson: (obj: any): any => ({`);
+            model.fields.forEach((f) => {
+                lines.push(`        "${f.name}": ${generateJsonLogic(f.typeRef, `obj.${(0, utils_1.camelCase)(f.name)}`, f.isOptional, 'toJson', camelNs)},`);
+            });
+            lines.push(`      })\n    },`);
+        });
+        lines.push(`  },`);
+    }
+    lines.push(`};\n`);
+    return lines.join('\n');
+}
+function generateJsonLogic(typeRef, access, isOpt, mode, ns) {
+    const wrap = (logic) => isOpt ? `(${access} == null ? undefined : ${logic})` : logic;
+    if (!typeRef || !typeRef.kind)
+        return access;
+    if (typeRef.kind === 'primitive') {
+        if (typeRef.value === 'dateTime') {
+            return mode === 'fromJson'
+                ? wrap(`new Date(${access})`)
+                : wrap(`${access}.toISOString()`);
+        }
+        if (typeRef.value === 'bytes') {
+            return mode === 'fromJson'
+                ? wrap(`new Uint8Array(${access})`)
+                : wrap(`Array.from(${access})`);
+        }
+        return access;
+    }
+    if (typeRef.kind === 'named') {
+        const name = (0, utils_1.pascalCase)(typeRef.value);
+        return wrap(`(Mappers.${ns}["${name}"] ? Mappers.${ns}["${name}"].${mode}(${access}) : ${access})`);
+    }
+    if (typeRef.kind === 'list') {
+        return wrap(`${access}.map((e: any) => ${generateJsonLogic(typeRef.value, 'e', false, mode, ns)})`);
+    }
+    return access;
+}

package/dist/generators/sdk-generator.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSdk = generateSdk;
+const utils_1 = require("./utils");
+function generateSdk(multiIr) {
+    const lines = [
+        `// GENERATED CODE – DO NOT EDIT.`,
+        `import { useAxiomQuery, useAxiomMutation } from 'atmx-react';`,
+        `import type { AxiomQueryDef } from 'atmx-react';`,
+        `import * as models from './models';\n`,
+    ];
+    for (const [ns, ir] of Object.entries(multiIr)) {
+        const pascalNs = (0, utils_1.pascalCase)(ns);
+        lines.push(`export class ${pascalNs}Module {`);
+        const endpoints = ir.endpoints || [];
+        endpoints.forEach((ep) => {
+            lines.push(generateEndpointHook(ep, ns, pascalNs));
+        });
+        lines.push(`}\n`);
+    }
+    lines.push(`export class AxiomSdk {`);
+    for (const ns of Object.keys(multiIr)) {
+        lines.push(`  public readonly ${(0, utils_1.camelCase)(ns)} = new ${(0, utils_1.pascalCase)(ns)}Module();`);
+    }
+    lines.push(`}\nexport const sdk = new AxiomSdk();`);
+    return lines.join("\n");
+}
+function generateEndpointHook(ep, ns, pascalNs) {
+    const isQuery = ep.method ? ep.method.toUpperCase() === "GET" : true;
+    const rawReturnType = (0, utils_1.mapTypeToTs)(ep.returnType, pascalNs);
+    const returnType = rawReturnType === "void" || rawReturnType === "any"
+        ? rawReturnType
+        : prefixModels(rawReturnType);
+    const params = ep.parameters || [];
+    const argType = params.length > 0
+        ? `{ ${params.map((p) => `${(0, utils_1.camelCase)(p.name)}${p.isOptional ? "?" : ""}: ${prefixModels((0, utils_1.mapTypeToTs)(p.typeRef, pascalNs))}`).join(", ")} }`
+        : "void";
+    const factoryLogic = generateQueryDefFactory(ep, returnType, ns);
+    // NEW: Every endpoint now generates BOTH a raw definition getter and a hook!
+    return `
+  /** Raw definition for <AxQuery> or <AxMutate> */
+  get${(0, utils_1.pascalCase)(ep.name)}Def(args: ${argType}): AxiomQueryDef<${returnType}> {
+    return (${factoryLogic})(args);
+  }
+
+  /** Reactive hook for functional components */
+  use${(0, utils_1.pascalCase)(ep.name)}${!isQuery ? "Mutation" : ""}(${isQuery ? `args: ${argType}, options?: { enabled?: boolean }` : ""}) {
+    const factory = ${factoryLogic};
+    return ${isQuery ? `useAxiomQuery<${returnType}>(factory(args), options)` : `useAxiomMutation<${returnType}, ${argType}>(factory)`};
+  }\n`;
+}
+function generateQueryDefFactory(ep, returnType, ns) {
+    const params = ep.parameters || [];
+    const bodyParam = params.find((p) => p.source === "body");
+    const payloadLogic = bodyParam
+        ? `const payload = (args as any).${(0, utils_1.camelCase)(bodyParam.name)};`
+        : `const payload = undefined;`;
+    const decLogic = generateLambda(ep.returnType, "fromJson", ns);
+    const serLogic = bodyParam
+        ? generateLambda(bodyParam.typeRef, "toJson", ns)
+        : `(p: any) => p`;
+    // THIN DEFINITION: Leaves URL logic up to ATMX Core Router
+    return `(args: any): AxiomQueryDef<${returnType}> => {
+      ${payloadLogic}
+      return {
+        namespace: "${ns}",
+        name: "${ep.name}",
+        endpointId: ${ep.id},
+        method: "${ep.method ? ep.method.toUpperCase() : "GET"}",
+        path: "${ep.path}",
+        payload: payload,
+        args: args as any,
+        decoder: ${decLogic},
+        serializer: ${serLogic},
+        isStream: ${ep.isStream === true}
+      };
+    }`;
+}
+function generateLambda(typeRef, mode, ns) {
+    if (!typeRef || !typeRef.kind || typeRef.kind === "void")
+        return mode === "fromJson" ? `() => undefined` : `(p: any) => p`;
+    if (typeRef.kind === "list" && typeRef.value?.kind === "named")
+        return `(data: any[]) => data.map(models.Mappers.${(0, utils_1.camelCase)(ns)}.${(0, utils_1.pascalCase)(typeRef.value.value)}.${mode})`;
+    if (typeRef.kind === "named")
+        return `models.Mappers.${(0, utils_1.camelCase)(ns)}.${(0, utils_1.pascalCase)(typeRef.value)}.${mode}`;
+    return `(data: any) => data`;
+}
+function prefixModels(type) {
+    if (!type || type === "void" || type === "any")
+        return type;
+    if (type.endsWith("[]"))
+        return `${prefixModels(type.slice(0, -2))}[]`;
+    if (type.startsWith("models."))
+        return type;
+    return `models.${type}`;
+}

package/dist/generators/utils.js

@@ -0,0 +1,59 @@
+"use strict";
+// atmx-cli/src/generators/utils.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pascalCase = pascalCase;
+exports.camelCase = camelCase;
+exports.normalizeIr = normalizeIr;
+exports.mapTypeToTs = mapTypeToTs;
+function pascalCase(str) {
+    if (!str)
+        return '';
+    return str
+        .split(/[_\-\s]+/)
+        .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+}
+function camelCase(str) {
+    const pascal = pascalCase(str);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function normalizeIr(obj) {
+    if (Array.isArray(obj))
+        return obj.map(normalizeIr);
+    if (obj !== null && typeof obj === 'object') {
+        const newObj = {};
+        for (const key of Object.keys(obj)) {
+            const camelKey = key.replace(/_([a-z])/g, (g) => g[1].toUpperCase());
+            newObj[camelKey] = normalizeIr(obj[key]);
+        }
+        return newObj;
+    }
+    return obj;
+}
+/**
+ * @param scopedNamespace If provided (e.g. 'Auth'), prefixes named types with 'models.Auth.'
+ */
+function mapTypeToTs(typeRef, ns) {
+    if (!typeRef)
+        return 'any';
+    if (typeRef.kind === 'primitive') {
+        switch (typeRef.value) {
+            case 'string': return 'string';
+            case 'int':
+            case 'float':
+            case 'double': return 'number';
+            case 'boolean': return 'boolean';
+            case 'dateTime': return 'Date';
+            case 'bytes': return 'Uint8Array';
+            default: return 'any';
+        }
+    }
+    if (typeRef.kind === 'named') {
+        const name = pascalCase(typeRef.value);
+        return ns ? `${ns}${name}` : name; // ✅ FIX HERE
+    }
+    if (typeRef.kind === 'list') {
+        return `${mapTypeToTs(typeRef.value, ns)}[]`;
+    }
+    return 'any';
+}

package/dist/index.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const model_generator_1 = require("./generators/model-generator");
+const sdk_generator_1 = require("./generators/sdk-generator");
+const utils_1 = require("./generators/utils");
+const program = new commander_1.Command();
+program
+    .name('atmx')
+    .description('Generate TypeScript SDK from an ATMX Multi-Contract Config')
+    .version('0.2.0');
+program
+    .command('generate')
+    .requiredOption('-c, --config <path>', 'Path to the atmx.config.json file')
+    .requiredOption('-o, --output <dir>', 'Output directory for generated files')
+    .action(async (options) => {
+    const configPath = path.resolve(options.config);
+    const outputDir = path.resolve(options.output);
+    if (!fs.existsSync(configPath)) {
+        console.error(`❌ Error: Config file not found at ${configPath}`);
+        process.exit(1);
+    }
+    // 1. Read the Config File
+    const rawConfig = await fs.readJSON(configPath);
+    if (!rawConfig.contracts || Object.keys(rawConfig.contracts).length === 0) {
+        console.error("❌ Error: Invalid config file. Missing 'contracts' dictionary.");
+        process.exit(1);
+    }
+    const configDir = path.dirname(configPath);
+    const multiIr = {};
+    // 2. Loop through the contracts and parse the local .axiom files
+    for (const [namespace, contract] of Object.entries(rawConfig.contracts)) {
+        // Resolve the .axiom file path relative to where the config file is located
+        // (e.g., if config is in /public, and file is "./auth.axiom", it looks in /public/auth.axiom)
+        const axiomFilePath = path.resolve(configDir, contract.file);
+        if (!fs.existsSync(axiomFilePath)) {
+            console.warn(`⚠️ Warning: Contract file not found for namespace '${namespace}' at ${axiomFilePath}. Skipping...`);
+            continue;
+        }
+        const rawFile = await fs.readJSON(axiomFilePath);
+        if (!rawFile.ir) {
+            console.warn(`⚠️ Warning: Invalid .axiom file for namespace '${namespace}'. Missing 'ir' property. Skipping...`);
+            continue;
+        }
+        // Normalize the IR (snake_case -> camelCase) and store it by namespace
+        multiIr[namespace] = (0, utils_1.normalizeIr)(rawFile.ir);
+        console.log(`✅ Loaded contract: [${namespace}] -> ${contract.file}`);
+    }
+    if (Object.keys(multiIr).length === 0) {
+        console.error("❌ Error: No valid contracts were loaded. Aborting generation.");
+        process.exit(1);
+    }
+    // Ensure output directory exists
+    await fs.ensureDir(outputDir);
+    // 3. Pass the MultiIR Map to the generators (We will update these in Phase 3)
+    const modelsContent = (0, model_generator_1.generateModels)(multiIr);
+    await fs.writeFile(path.join(outputDir, 'models.ts'), modelsContent);
+    const sdkContent = (0, sdk_generator_1.generateSdk)(multiIr);
+    await fs.writeFile(path.join(outputDir, 'sdk.ts'), sdkContent);
+    console.log(`\n🎉 ATMX Multi-Contract SDK generated successfully in ${outputDir}`);
+});
+program.parse();

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "atmx-cli",
+  "version": "0.1.93",
+  "description": "",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc"
+  },
+  "bin": {
+    "atmx": "./dist/index.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "commander": "^14.0.3",
+    "fs-extra": "^11.3.4"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^25.5.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  }
+}

package/src/generators/model-generator.ts

@@ -0,0 +1,148 @@
+// atmx-cli/src/generators/model-generator.ts
+import { AxiomEnum, AxiomModel, MultiIR } from '../types';
+import { pascalCase, camelCase, mapTypeToTs } from './utils';
+
+export function generateModels(multiIr: MultiIR): string {
+    const sections: string[] = [
+        `// GENERATED CODE – DO NOT EDIT.\n/* eslint-disable @typescript-eslint/no-explicit-any */\n`
+    ];
+
+    // 1. Generate flat exports (NO namespaces)
+    for (const [ns, ir] of Object.entries(multiIr)) {
+        const pascalNs = pascalCase(ns);
+
+        const enumsList = Array.isArray(ir.enums) ? ir.enums : Object.values(ir.enums || {});
+        const modelsList = Array.isArray(ir.models) ? ir.models : Object.values(ir.models || {});
+
+        enumsList.forEach((en: any) => sections.push(generateEnum(en, pascalNs)));
+        modelsList.forEach((model: any) => sections.push(generateInterface(model, pascalNs)));
+    }
+
+    // 2. Generate nested Mappers object
+    sections.push(generateMappers(multiIr));
+
+    return sections.join('\n');
+}
+
+function generateEnum(en: AxiomEnum, ns: string): string {
+    const name = `${ns}${pascalCase(en.name)}`;
+    const values = en.values.map(v => `  ${pascalCase(v)}: "${v}"`).join(',\n');
+
+    return `
+export const ${name} = {
+${values}
+} as const;
+
+export type ${name} = typeof ${name}[keyof typeof ${name}];
+`;
+}
+
+function generateInterface(model: AxiomModel, ns: string): string {
+    const name = `${ns}${pascalCase(model.name)}`;
+
+    const fields = model.fields.map(f => {
+        const type = mapTypeToTs(f.typeRef, ns); // ✅ pass namespace
+        return `  ${camelCase(f.name)}${f.isOptional ? '?' : ''}: ${type};`;
+    }).join('\n');
+
+    return `
+export interface ${name} {
+${fields}
+}
+`;
+}
+
+function generateMappers(multiIr: MultiIR): string {
+    const lines: string[] = [`export const Mappers: Record<string, any> = {`];
+
+    for (const [ns, ir] of Object.entries(multiIr)) {
+        const camelNs = camelCase(ns);
+        const pascalNs = pascalCase(ns);
+
+        lines.push(`  ${camelNs}: {`);
+
+        const modelsList = Array.isArray(ir.models) ? ir.models : Object.values(ir.models || {});
+
+        modelsList.forEach((model: any) => {
+            const name = pascalCase(model.name);
+            const fullType = `${pascalNs}${name}`; // no namespace now
+
+            lines.push(`    ${name}: {\n      fromJson: (json: any): ${fullType} => ({`);
+
+            model.fields.forEach((f: any) => {
+                lines.push(
+                    `        ${camelCase(f.name)}: ${generateJsonLogic(
+                        f.typeRef,
+                        `json["${f.name}"]`,
+                        f.isOptional,
+                        'fromJson',
+                        camelNs
+                    )},`
+                );
+            });
+
+            lines.push(`      }),\n      toJson: (obj: any): any => ({`);
+
+            model.fields.forEach((f: any) => {
+                lines.push(
+                    `        "${f.name}": ${generateJsonLogic(
+                        f.typeRef,
+                        `obj.${camelCase(f.name)}`,
+                        f.isOptional,
+                        'toJson',
+                        camelNs
+                    )},`
+                );
+            });
+
+            lines.push(`      })\n    },`);
+        });
+
+        lines.push(`  },`);
+    }
+
+    lines.push(`};\n`);
+    return lines.join('\n');
+}
+
+function generateJsonLogic(
+    typeRef: any,
+    access: string,
+    isOpt: boolean,
+    mode: 'fromJson' | 'toJson',
+    ns: string
+): string {
+    const wrap = (logic: string) =>
+        isOpt ? `(${access} == null ? undefined : ${logic})` : logic;
+
+    if (!typeRef || !typeRef.kind) return access;
+
+    if (typeRef.kind === 'primitive') {
+        if (typeRef.value === 'dateTime') {
+            return mode === 'fromJson'
+                ? wrap(`new Date(${access})`)
+                : wrap(`${access}.toISOString()`);
+        }
+        if (typeRef.value === 'bytes') {
+            return mode === 'fromJson'
+                ? wrap(`new Uint8Array(${access})`)
+                : wrap(`Array.from(${access})`);
+        }
+        return access;
+    }
+
+    if (typeRef.kind === 'named') {
+        const name = pascalCase(typeRef.value);
+        return wrap(
+            `(Mappers.${ns}["${name}"] ? Mappers.${ns}["${name}"].${mode}(${access}) : ${access})`
+        );
+    }
+
+    if (typeRef.kind === 'list') {
+        return wrap(
+            `${access}.map((e: any) => ${generateJsonLogic(typeRef.value, 'e', false, mode, ns)})`
+        );
+    }
+
+    return access;
+}

package/src/generators/sdk-generator.ts

@@ -0,0 +1,120 @@
+// FILE: atmx-cli/src/generators/sdk-generator.ts
+import { AxiomEndpoint, MultiIR } from "../types";
+import { pascalCase, camelCase, mapTypeToTs } from "./utils";
+
+export function generateSdk(multiIr: MultiIR): string {
+  const lines: string[] = [
+    `// GENERATED CODE – DO NOT EDIT.`,
+    `import { useAxiomQuery, useAxiomMutation } from 'atmx-react';`,
+    `import type { AxiomQueryDef } from 'atmx-react';`,
+    `import * as models from './models';\n`,
+  ];
+
+  for (const [ns, ir] of Object.entries(multiIr)) {
+    const pascalNs = pascalCase(ns);
+    lines.push(`export class ${pascalNs}Module {`);
+    const endpoints = ir.endpoints || [];
+    endpoints.forEach((ep: any) => {
+      lines.push(generateEndpointHook(ep, ns, pascalNs));
+    });
+    lines.push(`}\n`);
+  }
+
+  lines.push(`export class AxiomSdk {`);
+  for (const ns of Object.keys(multiIr)) {
+    lines.push(
+      `  public readonly ${camelCase(ns)} = new ${pascalCase(ns)}Module();`,
+    );
+  }
+  lines.push(`}\nexport const sdk = new AxiomSdk();`);
+
+  return lines.join("\n");
+}
+
+function generateEndpointHook(
+  ep: AxiomEndpoint,
+  ns: string,
+  pascalNs: string,
+): string {
+  const isQuery = ep.method ? ep.method.toUpperCase() === "GET" : true;
+  const rawReturnType = mapTypeToTs(ep.returnType, pascalNs);
+  const returnType =
+    rawReturnType === "void" || rawReturnType === "any"
+      ? rawReturnType
+      : prefixModels(rawReturnType);
+
+  const params = ep.parameters || [];
+  const argType =
+    params.length > 0
+      ? `{ ${params.map((p) => `${camelCase(p.name)}${p.isOptional ? "?" : ""}: ${prefixModels(mapTypeToTs(p.typeRef, pascalNs))}`).join(", ")} }`
+      : "void";
+
+  const factoryLogic = generateQueryDefFactory(ep, returnType, ns);
+
+  // NEW: Every endpoint now generates BOTH a raw definition getter and a hook!
+  return `
+  /** Raw definition for <AxQuery> or <AxMutate> */
+  get${pascalCase(ep.name)}Def(args: ${argType}): AxiomQueryDef<${returnType}> {
+    return (${factoryLogic})(args);
+  }
+
+  /** Reactive hook for functional components */
+  use${pascalCase(ep.name)}${!isQuery ? "Mutation" : ""}(${isQuery ? `args: ${argType}, options?: { enabled?: boolean }` : ""}) {
+    const factory = ${factoryLogic};
+    return ${isQuery ? `useAxiomQuery<${returnType}>(factory(args), options)` : `useAxiomMutation<${returnType}, ${argType}>(factory)`};
+  }\n`;
+}
+
+function generateQueryDefFactory(
+  ep: AxiomEndpoint,
+  returnType: string,
+  ns: string,
+): string {
+  const params = ep.parameters || [];
+  const bodyParam = params.find((p) => p.source === "body");
+  const payloadLogic = bodyParam
+    ? `const payload = (args as any).${camelCase(bodyParam.name)};`
+    : `const payload = undefined;`;
+  const decLogic = generateLambda(ep.returnType, "fromJson", ns);
+  const serLogic = bodyParam
+    ? generateLambda(bodyParam.typeRef, "toJson", ns)
+    : `(p: any) => p`;
+
+  // THIN DEFINITION: Leaves URL logic up to ATMX Core Router
+  return `(args: any): AxiomQueryDef<${returnType}> => {
+      ${payloadLogic}
+      return {
+        namespace: "${ns}",
+        name: "${ep.name}",
+        endpointId: ${ep.id},
+        method: "${ep.method ? ep.method.toUpperCase() : "GET"}",
+        path: "${ep.path}",
+        payload: payload,
+        args: args as any,
+        decoder: ${decLogic},
+        serializer: ${serLogic},
+        isStream: ${ep.isStream === true}
+      };
+    }`;
+}
+
+function generateLambda(
+  typeRef: any,
+  mode: "fromJson" | "toJson",
+  ns: string,
+): string {
+  if (!typeRef || !typeRef.kind || typeRef.kind === "void")
+    return mode === "fromJson" ? `() => undefined` : `(p: any) => p`;
+  if (typeRef.kind === "list" && typeRef.value?.kind === "named")
+    return `(data: any[]) => data.map(models.Mappers.${camelCase(ns)}.${pascalCase(typeRef.value.value)}.${mode})`;
+  if (typeRef.kind === "named")
+    return `models.Mappers.${camelCase(ns)}.${pascalCase(typeRef.value)}.${mode}`;
+  return `(data: any) => data`;
+}
+
+function prefixModels(type: string): string {
+  if (!type || type === "void" || type === "any") return type;
+  if (type.endsWith("[]")) return `${prefixModels(type.slice(0, -2))}[]`;
+  if (type.startsWith("models.")) return type;
+  return `models.${type}`;
+}

package/src/generators/utils.ts

@@ -0,0 +1,58 @@
+// atmx-cli/src/generators/utils.ts
+
+export function pascalCase(str: string): string {
+    if (!str) return '';
+    return str
+        .split(/[_\-\s]+/)
+        .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+}
+
+export function camelCase(str: string): string {
+    const pascal = pascalCase(str);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+
+export function normalizeIr(obj: any): any {
+    if (Array.isArray(obj)) return obj.map(normalizeIr);
+    if (obj !== null && typeof obj === 'object') {
+        const newObj: any = {};
+        for (const key of Object.keys(obj)) {
+            const camelKey = key.replace(/_([a-z])/g, (g) => g[1].toUpperCase());
+            newObj[camelKey] = normalizeIr(obj[key]);
+        }
+        return newObj;
+    }
+    return obj;
+}
+
+/**
+ * @param scopedNamespace If provided (e.g. 'Auth'), prefixes named types with 'models.Auth.'
+ */
+export function mapTypeToTs(typeRef: any, ns?: string): string {
+    if (!typeRef) return 'any';
+
+    if (typeRef.kind === 'primitive') {
+        switch (typeRef.value) {
+            case 'string': return 'string';
+            case 'int':
+            case 'float':
+            case 'double': return 'number';
+            case 'boolean': return 'boolean';
+            case 'dateTime': return 'Date';
+            case 'bytes': return 'Uint8Array';
+            default: return 'any';
+        }
+    }
+
+    if (typeRef.kind === 'named') {
+        const name = pascalCase(typeRef.value);
+        return ns ? `${ns}${name}` : name; // ✅ FIX HERE
+    }
+
+    if (typeRef.kind === 'list') {
+        return `${mapTypeToTs(typeRef.value, ns)}[]`;
+    }
+
+    return 'any';
+}

package/src/index.ts

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import { AtmxMultiConfig, MultiIR } from './types';
+import { generateModels } from './generators/model-generator';
+import { generateSdk } from './generators/sdk-generator';
+import { normalizeIr } from './generators/utils';
+
+const program = new Command();
+
+program
+    .name('atmx')
+    .description('Generate TypeScript SDK from an ATMX Multi-Contract Config')
+    .version('0.2.0');
+
+program
+    .command('generate')
+    .requiredOption('-c, --config <path>', 'Path to the atmx.config.json file')
+    .requiredOption('-o, --output <dir>', 'Output directory for generated files')
+    .action(async (options) => {
+        const configPath = path.resolve(options.config);
+        const outputDir = path.resolve(options.output);
+
+        if (!fs.existsSync(configPath)) {
+            console.error(`❌ Error: Config file not found at ${configPath}`);
+            process.exit(1);
+        }
+
+        // 1. Read the Config File
+        const rawConfig: AtmxMultiConfig = await fs.readJSON(configPath);
+
+        if (!rawConfig.contracts || Object.keys(rawConfig.contracts).length === 0) {
+            console.error("❌ Error: Invalid config file. Missing 'contracts' dictionary.");
+            process.exit(1);
+        }
+
+        const configDir = path.dirname(configPath);
+        const multiIr: MultiIR = {};
+
+        // 2. Loop through the contracts and parse the local .axiom files
+        for (const [namespace, contract] of Object.entries(rawConfig.contracts)) {
+            // Resolve the .axiom file path relative to where the config file is located
+            // (e.g., if config is in /public, and file is "./auth.axiom", it looks in /public/auth.axiom)
+            const axiomFilePath = path.resolve(configDir, contract.file);
+
+            if (!fs.existsSync(axiomFilePath)) {
+                console.warn(`⚠️ Warning: Contract file not found for namespace '${namespace}' at ${axiomFilePath}. Skipping...`);
+                continue;
+            }
+
+            const rawFile = await fs.readJSON(axiomFilePath);
+
+            if (!rawFile.ir) {
+                console.warn(`⚠️ Warning: Invalid .axiom file for namespace '${namespace}'. Missing 'ir' property. Skipping...`);
+                continue;
+            }
+
+            // Normalize the IR (snake_case -> camelCase) and store it by namespace
+            multiIr[namespace] = normalizeIr(rawFile.ir);
+            console.log(`✅ Loaded contract: [${namespace}] -> ${contract.file}`);
+        }
+
+        if (Object.keys(multiIr).length === 0) {
+            console.error("❌ Error: No valid contracts were loaded. Aborting generation.");
+            process.exit(1);
+        }
+
+        // Ensure output directory exists
+        await fs.ensureDir(outputDir);
+
+        // 3. Pass the MultiIR Map to the generators (We will update these in Phase 3)
+        const modelsContent = generateModels(multiIr);
+        await fs.writeFile(path.join(outputDir, 'models.ts'), modelsContent);
+
+        const sdkContent = generateSdk(multiIr);
+        await fs.writeFile(path.join(outputDir, 'sdk.ts'), sdkContent);
+
+        console.log(`\n🎉 ATMX Multi-Contract SDK generated successfully in ${outputDir}`);
+    });
+
+program.parse();

package/src/types.ts

@@ -0,0 +1,58 @@
+export interface AxiomIR {
+  serviceName: string;
+  endpoints: AxiomEndpoint[];
+  models: Record<string, AxiomModel>;
+  enums: Record<string, AxiomEnum>;
+}
+
+export interface AxiomEndpoint {
+  id: number;
+  name: string;
+  path: string;
+  method: string;
+  parameters: AxiomParameter[];
+  returnType: AxiomTypeRef;
+  returnIsOptional: boolean;
+  isStream: boolean;
+}
+
+export interface AxiomParameter {
+  name: string;
+  source: "path" | "query" | "body";
+  typeRef: AxiomTypeRef;
+  isOptional: boolean;
+}
+
+export type AxiomTypeRef =
+  | { kind: "primitive" | "named"; value: string }
+  | { kind: "list"; value: AxiomTypeRef }
+  | { kind: "map"; value: [AxiomTypeRef, AxiomTypeRef] }
+  | { kind: "void" };
+
+export interface AxiomModel {
+  name: string;
+  fields: AxiomField[];
+}
+
+export interface AxiomField {
+  name: string;
+  typeRef: AxiomTypeRef;
+  isOptional: boolean;
+}
+
+export interface AxiomEnum {
+  name: string;
+  values: string[];
+}
+
+export interface AtmxContractConfig {
+  file: string; // Path relative to the config file (e.g., "./auth.axiom")
+  baseUrl: string; // The URL for runtime (not used during code generation, but part of schema)
+}
+
+export interface AtmxMultiConfig {
+  contracts: Record<string, AtmxContractConfig>;
+}
+
+// A Map holding the normalized IR for each contract
+export type MultiIR = Record<string, AxiomIR>;

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "target": "ES2020",
+        "module": "CommonJS",
+        "lib": [
+            "ES2020"
+        ],
+        "rootDir": "src",
+        "outDir": "dist",
+        "moduleResolution": "node",
+        "esModuleInterop": true,
+        "forceConsistentCasingInFileNames": true,
+        "strict": true,
+        "skipLibCheck": true
+    },
+    "include": [
+        "src/**/*"
+    ]
+}