@atmyapp/cli 0.0.7 → 0.0.9

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

@@ -0,0 +1,36 @@
+export interface AmaSession {
+    token: string;
+    projectId: string;
+    url: string;
+}
+export interface SessionOverrides {
+    token?: string;
+    projectId?: string;
+    url?: string;
+}
+export type AmaFetch = ReturnType<typeof createAmaFetch>;
+export interface SseEvent<T = unknown> {
+    event?: string;
+    id?: string;
+    retry?: number;
+    data: string;
+    parsed?: T;
+    raw: string;
+}
+export interface StreamSseOptions<T = unknown> {
+    url: string;
+    fetchInit?: RequestInit;
+    signal?: AbortSignal;
+    onEvent: (event: SseEvent<T>) => void | Promise<void>;
+}
+export declare function resolveSession(overrides?: SessionOverrides): AmaSession;
+export declare function createAmaFetch(session: AmaSession): import("@better-fetch/fetch").BetterFetch<{
+    baseURL: string;
+    headers: {
+        Authorization: string;
+    };
+    throw: false;
+}, unknown, unknown, unknown>;
+export declare function projectUrl(session: AmaSession, subPath: string, query?: Record<string, string | number | boolean | null | undefined>): string;
+export declare function streamSse<T = unknown>(options: StreamSseOptions<T>): Promise<void>;
+export declare function encodePathSegment(path: string): string;

package/dist/cli/utils/http.js

@@ -0,0 +1,242 @@
+"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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSession = resolveSession;
+exports.createAmaFetch = createAmaFetch;
+exports.projectUrl = projectUrl;
+exports.streamSse = streamSse;
+exports.encodePathSegment = encodePathSegment;
+const fetch_1 = require("@better-fetch/fetch");
+const config_1 = require("./config");
+function resolveSession(overrides = {}) {
+    var _a, _b, _c;
+    let config;
+    try {
+        config = (0, config_1.getConfig)();
+    }
+    catch (error) {
+        throw new Error("AMA session not configured. Run 'ama use' first or supply --url, --token, and --project-id options.");
+    }
+    const token = (_a = overrides.token) !== null && _a !== void 0 ? _a : config.token;
+    const projectId = (_b = overrides.projectId) !== null && _b !== void 0 ? _b : config.projectId;
+    const url = (_c = overrides.url) !== null && _c !== void 0 ? _c : config.url;
+    if (!token) {
+        throw new Error("Authentication token is missing. Run 'ama use' or provide it with --token.");
+    }
+    if (!url) {
+        throw new Error("Project URL is missing. Run 'ama use' or provide it with --url.");
+    }
+    if (!projectId) {
+        throw new Error("Project ID is missing. Ensure the URL contains /projects/{id} or pass --project-id.");
+    }
+    return {
+        token,
+        projectId,
+        url: stripTrailingSlashes(url),
+    };
+}
+function createAmaFetch(session) {
+    return (0, fetch_1.createFetch)({
+        baseURL: ensureTrailingSlash(session.url),
+        headers: {
+            Authorization: `Bearer ${session.token}`,
+        },
+        throw: false,
+    });
+}
+function projectUrl(session, subPath, query) {
+    const base = ensureTrailingSlash(session.url);
+    const cleanPath = subPath.replace(/^\/+/, "");
+    const url = new URL(cleanPath, base);
+    if (query) {
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(query)) {
+            if (value === undefined || value === null) {
+                continue;
+            }
+            params.append(key, typeof value === "boolean" ? String(value) : String(value));
+        }
+        const queryString = params.toString();
+        if (queryString) {
+            url.search = queryString;
+        }
+    }
+    return url.toString();
+}
+function streamSse(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const { url, onEvent, signal, fetchInit = {} } = options;
+        const { signal: initSignal, headers: initHeaders } = fetchInit, restInit = __rest(fetchInit, ["signal", "headers"]);
+        const headers = new Headers(initHeaders !== null && initHeaders !== void 0 ? initHeaders : {});
+        if (!headers.has("Accept")) {
+            headers.set("Accept", "text/event-stream");
+        }
+        const requestInit = Object.assign(Object.assign({ method: (_a = restInit.method) !== null && _a !== void 0 ? _a : "GET" }, restInit), { headers, signal: signal !== null && signal !== void 0 ? signal : initSignal });
+        const response = yield fetch(url, requestInit);
+        if (!response.ok) {
+            const errorBody = yield safeReadText(response);
+            throw new Error(`Request failed with status ${response.status}: ${errorBody !== null && errorBody !== void 0 ? errorBody : "<no body>"}`);
+        }
+        if (!response.body) {
+            throw new Error("Streaming response body is not available.");
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder("utf-8");
+        let buffer = "";
+        while (true) {
+            const { done, value } = yield reader.read();
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            buffer = yield dispatchSseBuffer(buffer, onEvent);
+        }
+        buffer += decoder.decode();
+        yield dispatchSseBuffer(buffer, onEvent, true);
+    });
+}
+function encodePathSegment(path) {
+    return path
+        .split("/")
+        .map((segment) => segment === "" || segment === "." ? segment : encodeURIComponent(segment))
+        .join("/");
+}
+function stripTrailingSlashes(value) {
+    return value.replace(/\/+$/, "");
+}
+function ensureTrailingSlash(value) {
+    return value.endsWith("/") ? value : `${value}/`;
+}
+function dispatchSseBuffer(buffer_1, onEvent_1) {
+    return __awaiter(this, arguments, void 0, function* (buffer, onEvent, flush = false) {
+        let working = buffer;
+        while (true) {
+            const delimiter = nextDelimiter(working);
+            if (!delimiter) {
+                break;
+            }
+            const { index, length } = delimiter;
+            const rawEvent = working.slice(0, index);
+            working = working.slice(index + length);
+            if (!rawEvent.trim()) {
+                continue;
+            }
+            const event = parseSseEvent(rawEvent);
+            if (event) {
+                yield onEvent(event);
+            }
+        }
+        if (flush && working.trim()) {
+            const event = parseSseEvent(working);
+            if (event) {
+                yield onEvent(event);
+            }
+            return "";
+        }
+        return working;
+    });
+}
+function nextDelimiter(buffer) {
+    const lfIndex = buffer.indexOf("\n\n");
+    const crlfIndex = buffer.indexOf("\r\n\r\n");
+    if (lfIndex === -1 && crlfIndex === -1) {
+        return null;
+    }
+    if (lfIndex === -1) {
+        return { index: crlfIndex, length: 4 };
+    }
+    if (crlfIndex === -1) {
+        return { index: lfIndex, length: 2 };
+    }
+    return lfIndex < crlfIndex
+        ? { index: lfIndex, length: 2 }
+        : { index: crlfIndex, length: 4 };
+}
+function parseSseEvent(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const lines = trimmed.split(/\r?\n/);
+    const dataLines = [];
+    const event = {
+        data: "",
+        raw: trimmed,
+    };
+    for (const line of lines) {
+        if (!line) {
+            continue;
+        }
+        if (line.startsWith(":")) {
+            continue;
+        }
+        const separatorIndex = line.indexOf(":");
+        const field = separatorIndex === -1 ? line : line.slice(0, separatorIndex).trim();
+        const value = separatorIndex === -1
+            ? ""
+            : line
+                .slice(separatorIndex + 1)
+                .replace(/^\s+/, "");
+        switch (field) {
+            case "event":
+                event.event = value;
+                break;
+            case "data":
+                dataLines.push(value);
+                break;
+            case "id":
+                event.id = value;
+                break;
+            case "retry":
+                {
+                    const numeric = Number(value);
+                    if (!Number.isNaN(numeric)) {
+                        event.retry = numeric;
+                    }
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    event.data = dataLines.join("\n");
+    if (event.data) {
+        try {
+            event.parsed = JSON.parse(event.data);
+        }
+        catch (error) {
+            // Non-JSON payloads are expected occasionally (e.g. [DONE])
+        }
+    }
+    return event;
+}
+function safeReadText(response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return yield response.text();
+        }
+        catch (error) {
+            return null;
+        }
+    });
+}

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.7",
+  "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.6",
+    "@atmyapp/core": "^0.0.17",
     "@types/jest": "^29.5.14",
     "@typescript-eslint/eslint-plugin": "^8.32.1",
     "@typescript-eslint/parser": "^8.32.1",
@@ -40,6 +40,7 @@
     "typescript": "^5.8.3"
   },
   "dependencies": {
+    "@better-fetch/fetch": "^1.1.18",
     "chalk": "^4.1.2",
     "commander": "^14.0.0",
     "fast-glob": "^3.3.3",