@atmyapp/cli 0.0.8 → 0.0.9

package/README.md

@@ -19,6 +19,8 @@
   - [Content Definitions](#content-definitions)
   - [Event Definitions](#event-definitions)
   - [Image & File Definitions](#image--file-definitions)
+  - [Icon Definitions](#icon-definitions)
+  - [MDX Fields](#mdx-fields)
 - [💡 Examples](#-examples)
 - [🔧 Configuration](#-configuration)
 - [🏗️ Architecture](#-architecture)
@@ -290,6 +292,38 @@ export type UserIcon = AmaIconDef<"/icons/user">;
 export type ATMYAPP = [MenuIcon, SearchIcon, UserIcon];
 ```
 
+### MDX Fields
+
+Define MDX (Markdown with JSX) fields with component configurations using `AmaMdxFieldDef`, `AmaMdxConfigDef`, and `AmaComponentDef`:
+
+```typescript
+import {
+  AmaMdxFieldDef,
+  AmaMdxConfigDef,
+  AmaComponentDef,
+} from "@atmyapp/core";
+
+// 1. Define MDX components and their props
+type Callout = AmaComponentDef<"Callout", {
+  title: string;
+  type: "info" | "warning" | "error";
+}>;
+
+// 2. Create an MDX configuration
+type BlogMdxConfig = AmaMdxConfigDef<"blogComponents", [Callout]>;
+
+// 3. Use the config in your content definition
+interface BlogPost {
+  title: string;
+  content: AmaMdxFieldDef<BlogMdxConfig>;
+}
+
+export type BlogPostContent = AmaContentDef<"/blog/posts", BlogPost>;
+
+// 4. Export the configuration and definitions
+export type ATMYAPP = [BlogMdxConfig, BlogPostContent];
+```
+
 ## 💡 Examples
 
 ### 🏪 E-commerce Setup
@@ -364,13 +398,24 @@ import {
   AmaCustomEventDef,
   AmaImageDef,
   AmaIconDef,
+  AmaMdxFieldDef,
+  AmaMdxConfigDef,
+  AmaComponentDef,
 } from "@atmyapp/core";
 
+// MDX Components for blog
+type Callout = AmaComponentDef<"Callout", {
+  title: string;
+  type: "info" | "warning" | "error";
+}>;
+
+type BlogMdxConfig = AmaMdxConfigDef<"blogComponents", [Callout]>;
+
 // Blog content types
 interface BlogPost {
   title: string;
   slug: string;
-  content: string;
+  content: AmaMdxFieldDef<BlogMdxConfig>;
   excerpt: string;
   publishedAt: string;
   author: {
@@ -428,6 +473,7 @@ export type ATMYAPP = [
   BlogPosts,
   FeaturedPost,
   Categories,
+  BlogMdxConfig,
   BlogHeroImage,
   ShareIcon,
   LikeIcon,

package/dist/cli/commands/snapshot.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function snapshotCommand(): Command;

package/dist/cli/commands/snapshot.js

@@ -0,0 +1,287 @@
+"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;
+    };
+})();
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.snapshotCommand = snapshotCommand;
+const commander_1 = require("commander");
+const logger_1 = require("../logger");
+const http_1 = require("../utils/http");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const DEFAULT_OUTPUT_PATH = ".ama/local";
+const API_BASE = "https://ama-core.maciekgamro.workers.dev";
+/**
+ * Get the work-container API URL for snapshot operations
+ */
+function getSnapshotApiUrl(projectId, endpoint) {
+    return `${API_BASE}/v0/work-container/projects/${projectId}/${endpoint}`;
+}
+/**
+ * Create a new snapshot
+ */
+function createSnapshot(session, options, logger) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const url = getSnapshotApiUrl(session.projectId, "snapshot");
+        logger.info(`Creating snapshot for project ${session.projectId}...`);
+        logger.verbose_log(`POST ${url}`);
+        const response = yield fetch(url, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${session.token}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                branch: (_a = options.branch) !== null && _a !== void 0 ? _a : "main",
+                forceFullSync: (_b = options.forceSync) !== null && _b !== void 0 ? _b : false,
+            }),
+        });
+        if (!response.ok) {
+            const errorText = yield response.text();
+            throw new Error(`Failed to create snapshot: ${response.status} - ${errorText}`);
+        }
+        return response.json();
+    });
+}
+/**
+ * Get the latest snapshot info
+ */
+function getLatestSnapshot(session, options, logger) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const branch = (_a = options.branch) !== null && _a !== void 0 ? _a : "main";
+        const url = `${getSnapshotApiUrl(session.projectId, "latest-snapshot")}?branch=${branch}`;
+        logger.verbose_log(`GET ${url}`);
+        const response = yield fetch(url, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${session.token}`,
+            },
+        });
+        if (!response.ok) {
+            const errorText = yield response.text();
+            throw new Error(`Failed to get latest snapshot: ${response.status} - ${errorText}`);
+        }
+        return response.json();
+    });
+}
+/**
+ * Download a snapshot from the given URL
+ */
+function downloadSnapshotFile(downloadUrl, token, outputPath, logger) {
+    return __awaiter(this, void 0, void 0, function* () {
+        logger.info("Downloading snapshot...");
+        logger.verbose_log(`GET ${downloadUrl}`);
+        const response = yield fetch(downloadUrl, {
+            headers: {
+                Authorization: `Bearer ${token}`,
+            },
+        });
+        if (!response.ok) {
+            const errorText = yield response.text();
+            throw new Error(`Failed to download snapshot: ${response.status} - ${errorText}`);
+        }
+        // Ensure output directory exists
+        const outputDir = path.dirname(outputPath);
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
+        }
+        // Write the ZIP file
+        const arrayBuffer = yield response.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        fs.writeFileSync(outputPath, buffer);
+        return outputPath;
+    });
+}
+/**
+ * Extract a ZIP file to a directory
+ */
+function extractZip(zipPath, extractDir, logger) {
+    logger.info("Extracting snapshot...");
+    // Ensure extract directory exists and is empty
+    if (fs.existsSync(extractDir)) {
+        // Remove existing contents
+        fs.rmSync(extractDir, { recursive: true, force: true });
+    }
+    fs.mkdirSync(extractDir, { recursive: true });
+    // Use tar on Unix or PowerShell on Windows
+    const isWindows = process.platform === "win32";
+    try {
+        if (isWindows) {
+            // Use PowerShell's Expand-Archive
+            (0, child_process_1.execSync)(`powershell -Command "Expand-Archive -Path '${zipPath}' -DestinationPath '${extractDir}' -Force"`, { stdio: "pipe" });
+        }
+        else {
+            // Use unzip on Unix
+            (0, child_process_1.execSync)(`unzip -o "${zipPath}" -d "${extractDir}"`, { stdio: "pipe" });
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to extract snapshot: ${error instanceof Error ? error.message : error}`);
+    }
+}
+/**
+ * Format bytes to human readable string
+ */
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return "0 Bytes";
+    const k = 1024;
+    const sizes = ["Bytes", "KB", "MB", "GB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+}
+function snapshotCommand() {
+    const command = new commander_1.Command("snapshot").description("Manage storage snapshots for local fallback");
+    // Subcommand: create
+    command
+        .command("create")
+        .description("Create a new storage snapshot (may take a few minutes)")
+        .option("-t, --token <token>", "Authentication token")
+        .option("-u, --url <url>", "Project base URL")
+        .option("-p, --project-id <id>", "Project identifier")
+        .option("-b, --branch <branch>", "Branch name", "main")
+        .option("--force-sync", "Force full sync instead of incremental")
+        .option("--verbose", "Enable verbose logging")
+        .action((options) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        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 result = yield createSnapshot(session, options, logger);
+            if (!result.success || !result.data) {
+                throw new Error((_a = result.error) !== null && _a !== void 0 ? _a : "Failed to create snapshot");
+            }
+            const { data } = result;
+            logger.success("Snapshot created successfully!");
+            logger.info(`  Project: ${data.projectId}`);
+            logger.info(`  Branch: ${data.branch}`);
+            logger.info(`  Collections: ${data.stats.collectionsProcessed}`);
+            logger.info(`  Entries: ${data.stats.entriesIncluded}`);
+            logger.info(`  Blobs: ${data.stats.blobsIncluded}`);
+            logger.info(`  Files: ${data.stats.filesIncluded}`);
+            logger.info(`  Size: ${formatBytes(data.stats.totalSizeBytes)}`);
+            logger.info(`  Duration: ${data.duration}ms`);
+            logger.info(`  Download URL expires: ${data.expiresAt}`);
+            logger.info("");
+            logger.info("To download this snapshot, run:");
+            logger.info("  ama snapshot download");
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Unknown error";
+            logger.error(`Snapshot creation failed: ${message}`, error);
+            process.exit(1);
+        }
+    }));
+    // Subcommand: download
+    command
+        .command("download")
+        .description("Download the latest snapshot to local storage")
+        .option("-t, --token <token>", "Authentication token")
+        .option("-u, --url <url>", "Project base URL")
+        .option("-p, --project-id <id>", "Project identifier")
+        .option("-b, --branch <branch>", "Branch name", "main")
+        .option("-o, --output <path>", "Output directory", DEFAULT_OUTPUT_PATH)
+        .option("--verbose", "Enable verbose logging")
+        .action((options) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        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,
+            });
+            // Get the latest snapshot info
+            logger.info("Checking for latest snapshot...");
+            const latestResult = yield getLatestSnapshot(session, options, logger);
+            let downloadUrl;
+            if (latestResult.data && !latestResult.data.isExpired) {
+                // Use existing snapshot
+                logger.info(`Found existing snapshot from: ${latestResult.data.createdAt}`);
+                downloadUrl = latestResult.data.downloadUrl;
+            }
+            else {
+                // Need to create a new snapshot first
+                if ((_a = latestResult.data) === null || _a === void 0 ? void 0 : _a.isExpired) {
+                    logger.warn("Latest snapshot has expired, creating a new one...");
+                }
+                else {
+                    logger.info("No existing snapshot found, creating a new one...");
+                }
+                const createResult = yield createSnapshot(session, options, logger);
+                if (!createResult.success || !createResult.data) {
+                    throw new Error((_b = createResult.error) !== null && _b !== void 0 ? _b : "Failed to create snapshot");
+                }
+                downloadUrl = createResult.data.downloadUrl;
+                logger.info(`Snapshot created (${formatBytes(createResult.data.stats.totalSizeBytes)})`);
+            }
+            // Download the snapshot
+            const outputDir = path.resolve(process.cwd(), (_c = options.output) !== null && _c !== void 0 ? _c : DEFAULT_OUTPUT_PATH);
+            const zipPath = path.join(outputDir, "snapshot.zip");
+            yield downloadSnapshotFile(downloadUrl, session.token, zipPath, logger);
+            logger.success(`Downloaded to: ${zipPath}`);
+            // Extract the snapshot
+            extractZip(zipPath, outputDir, logger);
+            // Remove the ZIP file after extraction
+            fs.unlinkSync(zipPath);
+            logger.success(`Snapshot extracted to: ${outputDir}`);
+            logger.info("");
+            logger.info("Your local storage is now ready. Configure your client with:");
+            logger.info('  clientMode: "local"');
+            logger.info("  or");
+            logger.info('  clientMode: "with-fallback"');
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Unknown error";
+            logger.error(`Snapshot download failed: ${message}`, error);
+            process.exit(1);
+        }
+    }));
+    return command;
+}

package/dist/cli/index.js

@@ -6,6 +6,7 @@ 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")
@@ -14,6 +15,7 @@ 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/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/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);

package/dist/cli/utils/parallel-schema-processor.js

@@ -93,6 +93,13 @@ function processFilesParallel(files, tsconfigPath, continueOnError, logger, maxW
             logger.error("Parallel processing failed:", error);
             throw error;
         }
+        const { createProject, extractMdxConfigsFromSourceFiles } = require("./schema-processor");
+        const project = createProject(relevantFiles, tsconfigPath, logger);
+        const mdxConfigs = extractMdxConfigsFromSourceFiles(project.getSourceFiles(), logger);
+        if (mdxConfigs.length > 0) {
+            contents.push(...mdxConfigs);
+            successCount += mdxConfigs.length;
+        }
         return { contents, errors, successCount, failureCount };
     });
 }
@@ -114,7 +121,8 @@ function filterRelevantFiles(files, logger) {
                     // Quick text search for ATMYAPP export
                     const content = yield fs.readFile(file, "utf8");
                     // Simple regex to check for ATMYAPP exports
-                    if (/export\s+type\s+ATMYAPP\s*=/.test(content)) {
+                    if (/export\s+type\s+ATMYAPP\s*=/.test(content) ||
+                        /AmaMdxConfigDef/.test(content)) {
                         return file;
                     }
                     return null;

package/dist/cli/utils/schema-processor.d.ts

@@ -3,5 +3,6 @@ import { Logger } from "../logger";
 import { Content, ProcessingResult } from "../types/migrate";
 export declare function scanFiles(patterns: string[], logger: Logger): Promise<string[]>;
 export declare function createProject(files: string[], tsconfigPath: string, logger: Logger): Project;
+export declare function extractMdxConfigsFromSourceFiles(sourceFiles: SourceFile[], logger: Logger): Content[];
 export declare function processAtmyappExport(atmyappType: TypeAliasDeclaration, file: SourceFile, tsconfigPath: string, logger: Logger): Content[];
 export declare function processFiles(sourceFiles: SourceFile[], tsconfigPath: string, continueOnError: boolean, logger: Logger): ProcessingResult;

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

@@ -47,6 +47,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.scanFiles = scanFiles;
 exports.createProject = createProject;
+exports.extractMdxConfigsFromSourceFiles = extractMdxConfigsFromSourceFiles;
 exports.processAtmyappExport = processAtmyappExport;
 exports.processFiles = processFiles;
 const fast_glob_1 = __importDefault(require("fast-glob"));
@@ -202,6 +203,209 @@ function extractEventInfoFromAST(file, definitionType, logger) {
         return null;
     }
 }
+function getTypeAliasByName(file, name) {
+    const project = file.getProject();
+    for (const sourceFile of project.getSourceFiles()) {
+        const alias = sourceFile.getTypeAlias(name);
+        if (alias) {
+            return alias;
+        }
+    }
+    return undefined;
+}
+function extractStringLiteral(typeNode) {
+    if (!ts_morph_1.Node.isLiteralTypeNode(typeNode)) {
+        return null;
+    }
+    const literal = typeNode.getLiteral();
+    return ts_morph_1.Node.isStringLiteral(literal) ? literal.getLiteralValue() : null;
+}
+function mapPrimitiveType(typeNode) {
+    switch (typeNode.getKind()) {
+        case ts.SyntaxKind.StringKeyword:
+            return "string";
+        case ts.SyntaxKind.NumberKeyword:
+            return "number";
+        case ts.SyntaxKind.BooleanKeyword:
+            return "boolean";
+        case ts.SyntaxKind.ObjectKeyword:
+            return "object";
+        default:
+            break;
+    }
+    if (ts_morph_1.Node.isLiteralTypeNode(typeNode)) {
+        const literal = typeNode.getLiteral();
+        if (ts_morph_1.Node.isStringLiteral(literal)) {
+            return "string";
+        }
+        if (ts_morph_1.Node.isNumericLiteral(literal)) {
+            return "number";
+        }
+        if (literal.getKind() === ts.SyntaxKind.TrueKeyword || literal.getKind() === ts.SyntaxKind.FalseKeyword) {
+            return "boolean";
+        }
+    }
+    return null;
+}
+function mapPropType(typeNode, file) {
+    var _a;
+    if (ts_morph_1.Node.isUnionTypeNode(typeNode)) {
+        const nonNullable = typeNode
+            .getTypeNodes()
+            .filter((node) => node.getKind() !== ts.SyntaxKind.UndefinedKeyword &&
+            node.getKind() !== ts.SyntaxKind.NullKeyword);
+        if (nonNullable.length === 1) {
+            return mapPropType(nonNullable[0], file);
+        }
+        return "object";
+    }
+    if (ts_morph_1.Node.isArrayTypeNode(typeNode)) {
+        const elementType = mapPrimitiveType(typeNode.getElementTypeNode());
+        return elementType ? `${elementType}[]` : "object";
+    }
+    if (ts_morph_1.Node.isTypeReference(typeNode)) {
+        const typeName = typeNode.getTypeName();
+        if (ts_morph_1.Node.isIdentifier(typeName) && typeName.getText() === "Array") {
+            const args = typeNode.getTypeArguments();
+            if (args.length > 0) {
+                const elementType = mapPrimitiveType(args[0]);
+                return elementType ? `${elementType}[]` : "object";
+            }
+        }
+        return "object";
+    }
+    if (ts_morph_1.Node.isTypeLiteral(typeNode)) {
+        return "object";
+    }
+    return (_a = mapPrimitiveType(typeNode)) !== null && _a !== void 0 ? _a : "object";
+}
+function extractPropsFromTypeNode(typeNode, file) {
+    if (!typeNode) {
+        return undefined;
+    }
+    if (ts_morph_1.Node.isTypeReference(typeNode)) {
+        const typeName = typeNode.getTypeName();
+        if (ts_morph_1.Node.isIdentifier(typeName)) {
+            const alias = getTypeAliasByName(file, typeName.getText());
+            if (alias) {
+                return extractPropsFromTypeNode(alias.getTypeNode(), file);
+            }
+        }
+    }
+    if (!ts_morph_1.Node.isTypeLiteral(typeNode)) {
+        return undefined;
+    }
+    const props = {};
+    typeNode.getMembers().forEach((member) => {
+        if (!ts_morph_1.Node.isPropertySignature(member)) {
+            return;
+        }
+        const name = member.getName();
+        const propTypeNode = member.getTypeNode();
+        if (!propTypeNode || typeof name !== "string" || name.length === 0) {
+            return;
+        }
+        props[name] = mapPropType(propTypeNode, file);
+    });
+    return Object.keys(props).length > 0 ? props : undefined;
+}
+function extractComponentFromTypeNode(typeNode, file, logger) {
+    if (!ts_morph_1.Node.isTypeReference(typeNode)) {
+        return null;
+    }
+    const typeName = typeNode.getTypeName();
+    if (!ts_morph_1.Node.isIdentifier(typeName)) {
+        return null;
+    }
+    const typeNameText = typeName.getText();
+    if (typeNameText !== "AmaComponentDef") {
+        const alias = getTypeAliasByName(file, typeNameText);
+        if (!alias) {
+            return null;
+        }
+        const aliasTypeNode = alias.getTypeNode();
+        if (!aliasTypeNode) {
+            return null;
+        }
+        return extractComponentFromTypeNode(aliasTypeNode, file, logger);
+    }
+    const typeArguments = typeNode.getTypeArguments();
+    if (typeArguments.length === 0) {
+        return null;
+    }
+    const componentName = extractStringLiteral(typeArguments[0]);
+    if (!componentName) {
+        logger.warn(`MDX component name is not a string literal in ${file.getFilePath()}`);
+        return null;
+    }
+    const props = extractPropsFromTypeNode(typeArguments[1], file);
+    return Object.assign({ name: componentName }, (props ? { props } : {}));
+}
+function extractMdxConfigsFromAST(file, logger) {
+    const configs = {};
+    file.getTypeAliases().forEach((alias) => {
+        const typeNode = alias.getTypeNode();
+        if (!typeNode || !ts_morph_1.Node.isTypeReference(typeNode)) {
+            return;
+        }
+        const typeName = typeNode.getTypeName();
+        if (!ts_morph_1.Node.isIdentifier(typeName) || typeName.getText() !== "AmaMdxConfigDef") {
+            return;
+        }
+        const typeArguments = typeNode.getTypeArguments();
+        if (typeArguments.length < 2) {
+            return;
+        }
+        const configName = extractStringLiteral(typeArguments[0]);
+        if (!configName) {
+            logger.warn(`MDX config name is not a string literal in ${file.getFilePath()}`);
+            return;
+        }
+        const componentsArg = typeArguments[1];
+        const componentTypeNodes = [];
+        if (ts_morph_1.Node.isTupleTypeNode(componentsArg)) {
+            componentTypeNodes.push(...componentsArg.getElements());
+        }
+        else if (ts_morph_1.Node.isArrayTypeNode(componentsArg)) {
+            componentTypeNodes.push(componentsArg.getElementTypeNode());
+        }
+        if (componentTypeNodes.length === 0) {
+            configs[configName] = { components: {} };
+            return;
+        }
+        const components = {};
+        componentTypeNodes.forEach((componentNode) => {
+            const component = extractComponentFromTypeNode(componentNode, file, logger);
+            if (!component) {
+                return;
+            }
+            components[component.name] = component.props ? { props: component.props } : {};
+        });
+        configs[configName] = { components };
+    });
+    return configs;
+}
+function extractMdxConfigsFromSourceFiles(sourceFiles, logger) {
+    const mergedConfigs = {};
+    sourceFiles.forEach((file) => {
+        const fileConfigs = extractMdxConfigsFromAST(file, logger);
+        Object.entries(fileConfigs).forEach(([name, config]) => {
+            if (mergedConfigs[name]) {
+                logger.warn(`Duplicate MDX config "${name}" found in ${file.getFilePath()}`);
+                return;
+            }
+            mergedConfigs[name] = config;
+        });
+    });
+    return Object.entries(mergedConfigs).map(([name, config]) => ({
+        path: `__mdx_config__/${name}`,
+        structure: {
+            name,
+            components: config.components,
+        },
+        type: "mdxConfig",
+    }));
+}
 // Processes an ATMYAPP export to extract content definitions
 function processAtmyappExport(atmyappType, file, tsconfigPath, logger) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
@@ -416,5 +620,10 @@ function processFiles(sourceFiles, tsconfigPath, continueOnError, logger) {
             }
         });
     });
+    const mdxConfigs = extractMdxConfigsFromSourceFiles(sourceFiles, logger);
+    if (mdxConfigs.length > 0) {
+        contents.push(...mdxConfigs);
+        successCount += mdxConfigs.length;
+    }
     return { contents, errors, successCount, failureCount };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atmyapp/cli",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
@@ -28,7 +28,7 @@
   "license": "ISC",
   "description": "",
   "devDependencies": {
-    "@atmyapp/core": "^0.0.11",
+    "@atmyapp/core": "^0.0.17",
     "@types/jest": "^29.5.14",
     "@typescript-eslint/eslint-plugin": "^8.32.1",
     "@typescript-eslint/parser": "^8.32.1",