@atmyapp/cli 0.0.7 → 0.0.9

package/dist/cli/commands/upload.js

@@ -0,0 +1,334 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadCommand = uploadCommand;
+const commander_1 = require("commander");
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const logger_1 = require("../logger");
+const http_1 = require("../utils/http");
+const DEFAULT_BRANCH = "main";
+const DEFAULT_IGNORE_PATTERNS = ["**/.git/**", "**/.ama/**"];
+function uploadCommand() {
+    return new commander_1.Command("upload")
+        .description("Upload files to project storage")
+        .argument("[inputs...]")
+        .option("-t, --token <token>", "Authentication token override")
+        .option("-u, --url <url>", "Project base URL override")
+        .option("-p, --project-id <id>", "Project identifier override")
+        .option("-b, --base-path <path>", "Base remote path (relative to project root)")
+        .option("--branch <name>", "Branch to write to", DEFAULT_BRANCH)
+        .option("--environment-name <name>", "Environment name for scoped writes")
+        .option("--commit <message>", "Commit message recorded with the upload")
+        .option("--delete <path>", "Remote file path to delete (repeatable)", collectValues, [])
+        .option("--no-stream", "Disable streaming progress output (enabled by default)")
+        .option("--verbose", "Enable verbose logging")
+        .action((inputPatterns, options) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const logger = new logger_1.Logger(Boolean(options.verbose));
+        try {
+            const session = (0, http_1.resolveSession)({
+                token: options.token,
+                projectId: options.projectId,
+                url: options.url,
+            });
+            const basePath = normalizeBasePath(options.basePath);
+            const streamEnabled = options.stream !== false;
+            const files = yield prepareFiles(inputPatterns, basePath, logger);
+            const filesToDelete = normalizeDeletionPaths((_a = options.delete) !== null && _a !== void 0 ? _a : [], basePath, logger);
+            if (files.length === 0 && filesToDelete.length === 0) {
+                throw new Error("Nothing to upload. Provide file inputs or --delete paths to process.");
+            }
+            const body = {
+                files,
+            };
+            if (filesToDelete.length > 0) {
+                body.filesToDelete = filesToDelete;
+            }
+            if (options.commit) {
+                body.commitMessage = options.commit;
+            }
+            const query = {
+                branch: (_b = options.branch) !== null && _b !== void 0 ? _b : DEFAULT_BRANCH,
+            };
+            if (options.environmentName) {
+                query.environment_name = options.environmentName;
+            }
+            if (streamEnabled) {
+                query.stream = true;
+                yield performStreamingUpload(session, basePath, body, query, logger);
+            }
+            else {
+                yield performStandardUpload(session, basePath, body, query, logger);
+            }
+            logger.success("Upload completed successfully.");
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error(`Upload failed: ${message}`);
+            process.exit(1);
+        }
+    }));
+}
+function collectValues(value, previous) {
+    previous.push(value);
+    return previous;
+}
+function normalizeBasePath(basePath) {
+    if (!basePath) {
+        return undefined;
+    }
+    const trimmed = basePath.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const normalized = toPosix(trimmed)
+        .replace(/^\.\/?/, "")
+        .replace(/\/+$/, "");
+    return normalized || undefined;
+}
+function toPosix(value) {
+    return value.replace(/\\/g, "/");
+}
+function prepareFiles(patterns, basePath, logger) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!patterns || patterns.length === 0) {
+            return [];
+        }
+        const resolvedPaths = new Set();
+        for (const pattern of patterns) {
+            const expanded = yield expandInput(pattern);
+            if (expanded.length === 0) {
+                logger.warn(`No files matched pattern '${pattern}'.`);
+            }
+            for (const filePath of expanded) {
+                resolvedPaths.add(path_1.default.resolve(filePath));
+            }
+        }
+        const sortedPaths = Array.from(resolvedPaths).sort();
+        const files = [];
+        for (const absolutePath of sortedPaths) {
+            const buffer = yield fs_1.promises.readFile(absolutePath);
+            const relativePath = path_1.default.relative(process.cwd(), absolutePath) ||
+                path_1.default.basename(absolutePath);
+            const posixPath = toPosix(relativePath);
+            const remotePath = computeRemotePath(posixPath, basePath, logger);
+            logger.verbose_log(`Preparing file '${absolutePath}' as remote path '${remotePath}'.`);
+            files.push({
+                path: remotePath,
+                content: buffer.toString("base64"),
+            });
+        }
+        return files;
+    });
+}
+function expandInput(input) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cwd = process.cwd();
+        const absoluteCandidate = path_1.default.resolve(cwd, input);
+        try {
+            const stats = yield fs_1.promises.stat(absoluteCandidate);
+            if (stats.isDirectory()) {
+                const entries = yield (0, fast_glob_1.default)("**/*", {
+                    cwd: absoluteCandidate,
+                    dot: true,
+                    onlyFiles: true,
+                    followSymbolicLinks: false,
+                    ignore: DEFAULT_IGNORE_PATTERNS,
+                });
+                return entries.map((entry) => path_1.default.resolve(absoluteCandidate, entry));
+            }
+            if (stats.isFile()) {
+                return [absoluteCandidate];
+            }
+        }
+        catch (error) {
+            // Treat as glob when path resolution fails
+        }
+        const normalizedPattern = toPosix(input);
+        const matches = yield (0, fast_glob_1.default)(normalizedPattern, {
+            cwd,
+            dot: true,
+            onlyFiles: true,
+            followSymbolicLinks: false,
+            ignore: DEFAULT_IGNORE_PATTERNS,
+            unique: true,
+        });
+        return matches.map((match) => path_1.default.resolve(cwd, match));
+    });
+}
+function computeRemotePath(posixPath, basePath, logger) {
+    const cleaned = posixPath.replace(/^\.\//, "");
+    if (!basePath) {
+        return cleaned;
+    }
+    const relativeToBase = path_1.default.posix.relative(basePath, cleaned);
+    if (relativeToBase.startsWith("..")) {
+        logger.warn(`File '${cleaned}' is outside the base path '${basePath}'. Using absolute path.`);
+        return cleaned;
+    }
+    const normalized = relativeToBase.replace(/^\.\//, "");
+    const finalSegment = normalized || path_1.default.posix.basename(cleaned);
+    return `./${finalSegment}`;
+}
+function normalizeDeletionPaths(values, basePath, logger) {
+    if (!values || values.length === 0) {
+        return [];
+    }
+    const result = [];
+    for (const original of values) {
+        const trimmed = original.trim();
+        if (!trimmed) {
+            continue;
+        }
+        const posix = toPosix(trimmed);
+        if (posix.startsWith("./")) {
+            result.push(`./${posix.replace(/^\.\/+/, "")}`);
+            continue;
+        }
+        if (posix.startsWith("/")) {
+            result.push(posix.replace(/^\/+/, ""));
+            continue;
+        }
+        result.push(computeRemotePath(posix, basePath, logger));
+    }
+    return result;
+}
+function buildUploadEndpoint(session, basePath) {
+    const projectSegment = `v0/projects/${encodeURIComponent(session.projectId)}/storage/f`;
+    if (!basePath) {
+        return projectSegment;
+    }
+    const encodedBase = (0, http_1.encodePathSegment)(basePath);
+    return `${projectSegment}/${encodedBase}`;
+}
+function performStreamingUpload(session, basePath, body, query, logger) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const endpoint = buildUploadEndpoint(session, basePath);
+        const url = (0, http_1.projectUrl)(session, endpoint, {
+            branch: query.branch,
+            environment_name: query.environment_name,
+            stream: true,
+        });
+        const summary = {
+            updated: new Set(),
+            deleted: new Set(),
+            errors: new Map(),
+            hadErrorEvent: false,
+        };
+        yield (0, http_1.streamSse)({
+            url,
+            fetchInit: {
+                method: "PUT",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${session.token}`,
+                },
+                body: JSON.stringify(body),
+            },
+            onEvent: (event) => __awaiter(this, void 0, void 0, function* () {
+                if (event.data === "[DONE]") {
+                    return;
+                }
+                const payload = event.parsed;
+                if (!payload) {
+                    logger.verbose_log(`SSE: ${event.data}`);
+                    return;
+                }
+                if (payload.message) {
+                    logger.info(payload.message);
+                }
+                if (payload.updated) {
+                    payload.updated.forEach((item) => summary.updated.add(item));
+                }
+                if (payload.deleted) {
+                    payload.deleted.forEach((item) => summary.deleted.add(item));
+                }
+                if (payload.errors) {
+                    Object.entries(payload.errors).forEach(([key, value]) => {
+                        summary.errors.set(key, value);
+                        logger.error(`Error processing '${key}': ${value}`);
+                    });
+                }
+                if (payload.type === "error" || payload.success === false) {
+                    summary.hadErrorEvent = true;
+                }
+                if (payload.type === "complete") {
+                    logger.info("Upload stream completed.");
+                }
+            }),
+        });
+        if (summary.updated.size > 0) {
+            logger.success(`Updated ${summary.updated.size} file(s): ${Array.from(summary.updated).join(", ")}`);
+        }
+        if (summary.deleted.size > 0) {
+            logger.warn(`Deleted ${summary.deleted.size} file(s): ${Array.from(summary.deleted).join(", ")}`);
+        }
+        if (summary.errors.size > 0 || summary.hadErrorEvent) {
+            throw new Error("Upload completed with errors. Check the log for details.");
+        }
+    });
+}
+function performStandardUpload(session, basePath, body, query, logger) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const endpoint = buildUploadEndpoint(session, basePath);
+        const url = (0, http_1.projectUrl)(session, endpoint, {
+            branch: query.branch,
+            environment_name: query.environment_name,
+        });
+        const fetcher = (0, http_1.createAmaFetch)(session);
+        const { data, error } = yield fetcher(url, {
+            method: "PUT",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(body),
+        });
+        if (error) {
+            const errorMessage = typeof error === "string"
+                ? error
+                : error instanceof Error
+                    ? error.message
+                    : (_a = error.message) !== null && _a !== void 0 ? _a : (error.status
+                        ? `HTTP ${error.status}`
+                        : "Unknown error");
+            throw new Error(`Request failed: ${errorMessage}`);
+        }
+        if (!data) {
+            throw new Error("No response data received from the server.");
+        }
+        if (!data.success) {
+            throw new Error(data.error || "Upload failed without a server error message.");
+        }
+        const payload = data.data;
+        if (!payload) {
+            logger.success("Server reported success with no additional details.");
+            return;
+        }
+        if (payload.updated && payload.updated.length > 0) {
+            logger.success(`Updated files: ${payload.updated.join(", ")}`);
+        }
+        if (payload.deleted && payload.deleted.length > 0) {
+            logger.warn(`Deleted files: ${payload.deleted.join(", ")}`);
+        }
+        if (payload.errors && Object.keys(payload.errors).length > 0) {
+            for (const [pathKey, value] of Object.entries(payload.errors)) {
+                logger.error(`Error for '${pathKey}': ${value}`);
+            }
+            throw new Error("Upload completed with file-specific errors.");
+        }
+    });
+}

package/dist/cli/commands/use.js

@@ -41,13 +41,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useCommand = useCommand;
 const commander_1 = require("commander");
-const chalk_1 = __importDefault(require("chalk"));
+const logger_1 = require("../logger");
 const config_1 = require("../utils/config");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -56,7 +53,10 @@ function useCommand() {
         .description("Set authentication token for AMA project")
         .option("-t, --token <token>", "Authentication token")
         .option("-u, --url <url>", "Project base URL")
+        .option("-p, --project-id <id>", "Project identifier override")
+        .option("--verbose", "Enable verbose logging")
         .action((options) => __awaiter(this, void 0, void 0, function* () {
+        const logger = new logger_1.Logger(Boolean(options.verbose));
         const rlQuestion = (query) => {
             return new Promise((resolve) => {
                 const rl = require("readline").createInterface({
@@ -74,35 +74,47 @@ function useCommand() {
             const projectUrl = options.url || (yield rlQuestion("Enter the project URL: "));
             const authToken = options.token ||
                 (yield rlQuestion("Enter the authentication token: "));
+            const detectProjectId = (url) => {
+                const match = url.match(/\/projects\/([^/?#]+)/i);
+                return match === null || match === void 0 ? void 0 : match[1];
+            };
+            const detectedProjectId = detectProjectId(projectUrl);
+            const projectId = options.projectId || detectedProjectId;
+            if (!projectId) {
+                logger.warn("Project ID could not be detected from the URL. Rerun with --project-id to set it explicitly.");
+            }
             // Create .ama directory if it doesn't exist
             const amaDir = path.join(process.cwd(), ".ama");
             if (!fs.existsSync(amaDir)) {
                 fs.mkdirSync(amaDir, { recursive: true });
+                logger.verbose_log(`Created directory ${amaDir}.`);
             }
             // Add .gitignore if it doesn't exist or update it
             const gitignorePath = path.join(process.cwd(), ".gitignore");
             const gitignoreEntry = "\n# AMA configuration\n.ama/session.json\n";
             if (!fs.existsSync(gitignorePath)) {
                 fs.writeFileSync(gitignorePath, gitignoreEntry);
+                logger.verbose_log(`Created ${gitignorePath} with AMA ignore rules.`);
             }
             else {
                 const currentContent = fs.readFileSync(gitignorePath, "utf8");
                 if (!currentContent.includes(".ama/session.json")) {
                     fs.appendFileSync(gitignorePath, gitignoreEntry);
+                    logger.verbose_log(`Updated ${gitignorePath} with AMA ignore rules.`);
                 }
             }
-            const projectId = "proj_" + Math.random().toString(36).slice(2, 9);
             const configData = { token: authToken, projectId, url: projectUrl };
             (0, config_1.setConfig)(configData);
             // Save session data to .ama/session.json
             fs.writeFileSync(path.join(amaDir, "session.json"), JSON.stringify(configData, null, 2));
-            console.log(chalk_1.default.green("🔐 Successfully authenticated and joined project"));
-            console.log(chalk_1.default.yellow("⚠️  Warning: Keep your .ama/session.json file private and do not commit it to version control"));
-            console.log(chalk_1.default.blue("ℹ️  Note: Session file has been automatically added to .gitignore"));
+            logger.success("Authentication details saved for the project.");
+            logger.info(`Session file stored at ${path.join(amaDir, "session.json")}.`);
+            logger.warn("Keep your .ama/session.json file private and exclude it from version control.");
+            logger.info("Session file has been added to the project .gitignore file.");
         }
         catch (error) {
             const message = error instanceof Error ? error.message : "Unknown error";
-            console.error(chalk_1.default.red(`❌ Error: ${message}`));
+            logger.error(`Configuration update failed: ${message}`, error);
             process.exit(1);
         }
     }));

package/dist/cli/index.js

@@ -4,12 +4,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const migrate_1 = require("./commands/migrate");
 const use_1 = require("./commands/use");
+const upload_1 = require("./commands/upload");
+const generate_1 = require("./commands/generate");
+const snapshot_1 = require("./commands/snapshot");
 const program = new commander_1.Command()
     .name("ama")
     .description("AtMyApp CLI Tool")
     .version("1.0.0");
 program.addCommand((0, use_1.useCommand)());
 program.addCommand((0, migrate_1.migrateCommand)());
+program.addCommand((0, upload_1.uploadCommand)());
+program.addCommand((0, generate_1.generateCommand)());
+program.addCommand((0, snapshot_1.snapshotCommand)());
 program.parseAsync(process.argv).catch((err) => {
     console.error("Error:", err.message);
     process.exit(1);

package/dist/cli/logger/index.d.ts

@@ -1,12 +1,14 @@
 /**
- * Logger utility to handle verbose logging
+ * Logger utility to handle verbose logging with consistent formatting.
  */
 export declare class Logger {
-    private verbose;
+    private readonly verbose;
     constructor(verbose: boolean);
     info(message: string): void;
     success(message: string): void;
+    warn(message: string): void;
     error(message: string, error?: unknown): void;
     verbose_log(message: string): void;
-    warn(message: string): void;
+    private write;
+    private formatErrorDetail;
 }

package/dist/cli/logger/index.js

@@ -5,30 +5,76 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logger = void 0;
 const chalk_1 = __importDefault(require("chalk"));
+const LEVEL_CONFIG = {
+    info: { label: "INFO", style: (text) => chalk_1.default.blueBright.bold(text), method: "log" },
+    success: { label: "SUCCESS", style: (text) => chalk_1.default.greenBright.bold(text), method: "log" },
+    warn: { label: "WARN", style: (text) => chalk_1.default.yellowBright.bold(text), method: "warn" },
+    error: { label: "ERROR", style: (text) => chalk_1.default.redBright.bold(text), method: "error" },
+    verbose: { label: "VERBOSE", style: (text) => chalk_1.default.gray.bold(text), method: "log" },
+};
 /**
- * Logger utility to handle verbose logging
+ * Logger utility to handle verbose logging with consistent formatting.
  */
 class Logger {
     constructor(verbose) {
         this.verbose = verbose;
     }
     info(message) {
-        console.log(chalk_1.default.blue(message));
+        this.write("info", message);
     }
     success(message) {
-        console.log(chalk_1.default.green(message));
+        this.write("success", message);
+    }
+    warn(message) {
+        this.write("warn", message);
     }
     error(message, error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error(chalk_1.default.red(message), error ? chalk_1.default.red(errorMessage) : "");
+        const detail = this.formatErrorDetail(error);
+        const formatted = detail ? `${message}\n${chalk_1.default.gray(detail)}` : message;
+        this.write("error", formatted);
     }
     verbose_log(message) {
-        if (this.verbose) {
-            console.log(chalk_1.default.cyan(`[VERBOSE] ${message}`));
+        if (!this.verbose) {
+            return;
         }
+        this.write("verbose", message);
     }
-    warn(message) {
-        console.warn(chalk_1.default.yellow(message));
+    write(level, message) {
+        const { label, style, method } = LEVEL_CONFIG[level];
+        const rawLabel = `[${label}]`;
+        const styledLabel = style(rawLabel);
+        const lines = message.split(/\r?\n/);
+        const continuationPrefix = " ".repeat(rawLabel.length + 1);
+        for (const [index, line] of lines.entries()) {
+            const output = index === 0 ? `${styledLabel} ${line}` : `${continuationPrefix}${line}`;
+            if (method === "warn") {
+                console.warn(output);
+            }
+            else if (method === "error") {
+                console.error(output);
+            }
+            else {
+                console.log(output);
+            }
+        }
+    }
+    formatErrorDetail(error) {
+        var _a;
+        if (!error) {
+            return undefined;
+        }
+        if (error instanceof Error) {
+            return (_a = error.stack) !== null && _a !== void 0 ? _a : error.message;
+        }
+        if (typeof error === "string") {
+            return error;
+        }
+        try {
+            return JSON.stringify(error, null, 2);
+        }
+        catch (_b) {
+            return String(error);
+        }
     }
 }
 exports.Logger = Logger;

package/dist/cli/types/migrate.d.ts

@@ -15,6 +15,11 @@ export interface OutputDefinition {
     events: Record<string, EventConfig>;
     args: any[];
     metadata?: any;
+    mdx?: Record<string, {
+        components: Record<string, {
+            props?: Record<string, string>;
+        }>;
+    }>;
 }
 export interface MigrateOptions {
     dryRun: boolean;

package/dist/cli/utils/collection-transformer.js

@@ -29,6 +29,22 @@ function detectAmaAssetField(schema) {
     }
     return Object.assign({ format: assetMapping.format, semanticType: assetMapping.semanticType }, (imageOptions ? { imageOptions } : {}));
 }
+function detectAmaMdxField(schema) {
+    var _a, _b, _c, _d, _e, _f;
+    const amaType = (_b = (_a = schema === null || schema === void 0 ? void 0 : schema.properties) === null || _a === void 0 ? void 0 : _a.__amatype) === null || _b === void 0 ? void 0 : _b.const;
+    if (amaType !== "AmaMdxDef") {
+        return null;
+    }
+    const mdxConfigConst = (_d = (_c = schema === null || schema === void 0 ? void 0 : schema.properties) === null || _c === void 0 ? void 0 : _c.mdxConfig) === null || _d === void 0 ? void 0 : _d.const;
+    if (typeof mdxConfigConst === "string") {
+        return { mdxConfig: mdxConfigConst };
+    }
+    const mdxConfigEnum = (_f = (_e = schema === null || schema === void 0 ? void 0 : schema.properties) === null || _e === void 0 ? void 0 : _e.mdxConfig) === null || _f === void 0 ? void 0 : _f.enum;
+    if (Array.isArray(mdxConfigEnum) && typeof mdxConfigEnum[0] === "string") {
+        return { mdxConfig: mdxConfigEnum[0] };
+    }
+    return null;
+}
 function ensureDescription(description, fallback) {
     if (typeof description === "string" && description.trim().length > 0) {
         return description.trim();
@@ -136,6 +152,18 @@ function convertField(schema, fieldName, logger, breadcrumb) {
         }
         return base;
     }
+    const mdxField = detectAmaMdxField(schema);
+    if (mdxField) {
+        const description = ensureDescription(schema.description, `Generated description for ${breadcrumb}`);
+        return {
+            type: "string",
+            description,
+            format: "mdx",
+            storeInBlob: true,
+            __amatype: "AmaMdxDef",
+            mdxConfig: mdxField.mdxConfig,
+        };
+    }
     let type = inferType(schema);
     if (!type) {
         logger.error(`Collection conversion failed for field "${breadcrumb}": could not determine field type.`);

package/dist/cli/utils/config.d.ts

@@ -1,10 +1,10 @@
-type Config = {
+export interface AmaConfig {
     token?: string;
     projectId?: string;
+    url?: string;
     include?: string[];
     description?: string;
     args?: Record<string, string>;
-};
-export declare function setConfig(config: Config): void;
-export declare function getConfig(): Config;
-export {};
+}
+export declare function setConfig(config: AmaConfig): void;
+export declare function getConfig(): AmaConfig;

package/dist/cli/utils/config.js

@@ -19,7 +19,6 @@ function ensureConfigDir() {
 }
 function setConfig(config) {
     ensureConfigDir();
-    (0, fs_1.writeFileSync)(CONFIG_PATH, JSON.stringify(config, null, 2));
     try {
         (0, fs_1.writeFileSync)(CONFIG_PATH, JSON.stringify(config, null, 2));
     }

package/dist/cli/utils/content-processor.js

@@ -105,17 +105,26 @@ function generateOutput(contents, config, logger) {
     // Separate events from regular definitions
     const events = {};
     const definitions = {};
+    const mdx = {};
     transformedContents.forEach((content) => {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e, _f;
+        if (content.type === "mdxConfig") {
+            const name = (_a = content.structure) === null || _a === void 0 ? void 0 : _a.name;
+            const components = (_b = content.structure) === null || _b === void 0 ? void 0 : _b.components;
+            if (typeof name === "string" && components && typeof components === "object") {
+                mdx[name] = { components };
+            }
+            return;
+        }
         const contentType = determineContentType(content);
         if (contentType === "event") {
             logger.verbose_log(`Processing event: ${content.path}`);
             // Extract event ID from path or structure
             let eventId = content.path;
-            if ((_c = (_b = (_a = content.structure) === null || _a === void 0 ? void 0 : _a.properties) === null || _b === void 0 ? void 0 : _b.id) === null || _c === void 0 ? void 0 : _c.const) {
+            if ((_e = (_d = (_c = content.structure) === null || _c === void 0 ? void 0 : _c.properties) === null || _d === void 0 ? void 0 : _d.id) === null || _e === void 0 ? void 0 : _e.const) {
                 eventId = content.structure.properties.id.const;
             }
-            else if ((_d = content.structure) === null || _d === void 0 ? void 0 : _d.id) {
+            else if ((_f = content.structure) === null || _f === void 0 ? void 0 : _f.id) {
                 eventId = content.structure.id;
             }
             const eventConfig = extractEventConfig(content);
@@ -136,12 +145,8 @@ function generateOutput(contents, config, logger) {
         }
     });
     logger.verbose_log("Generating base output definition");
-    const baseOutput = {
-        description: config.description || "AMA Definitions",
-        definitions,
-        events,
-        args: config.args || {},
-    };
+    const baseOutput = Object.assign({ description: config.description || "AMA Definitions", definitions,
+        events, args: config.args || {} }, (Object.keys(mdx).length > 0 ? { mdx } : {}));
     // Transform the final output through the pipeline
     logger.verbose_log("Applying output transformations");
     const finalOutput = definition_processor_1.definitionPipeline.transformOutput(baseOutput, config, logger);