@atmyapp/cli 0.0.2 → 0.0.4

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

@@ -0,0 +1,147 @@
+"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.scanFilesOptimized = scanFilesOptimized;
+exports.processFilesParallel = processFilesParallel;
+exports.optimizedMigrationPipeline = optimizedMigrationPipeline;
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const worker_pool_1 = require("./worker-pool");
+const path_1 = __importDefault(require("path"));
+// Enhanced version of scanFiles with better performance
+function scanFilesOptimized(patterns, logger) {
+    return __awaiter(this, void 0, void 0, function* () {
+        logger.info("🔍 Scanning files with optimized parallel processing...");
+        logger.verbose_log(`Using patterns: ${patterns.join(", ")}`);
+        const files = yield (0, fast_glob_1.default)(patterns, {
+            ignore: ["**/node_modules/**", "**/test/**", "**/dist/**", "**/.ama/**"],
+            absolute: true,
+            cwd: process.cwd(),
+            suppressErrors: true, // Don't fail on permission errors
+            followSymbolicLinks: false, // Skip symlinks for better performance
+        });
+        logger.verbose_log(`Found ${files.length} files matching patterns`);
+        return files;
+    });
+}
+// Parallel processing of files using worker threads
+function processFilesParallel(files, tsconfigPath, continueOnError, logger, maxWorkers) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const contents = [];
+        const errors = [];
+        let successCount = 0;
+        let failureCount = 0;
+        logger.info(`📚 Processing ${files.length} files in parallel...`);
+        // Filter files that likely contain ATMYAPP exports for better performance
+        const relevantFiles = yield filterRelevantFiles(files, logger);
+        if (relevantFiles.length === 0) {
+            logger.warn("No files with ATMYAPP exports found");
+            return { contents, errors, successCount, failureCount };
+        }
+        logger.info(`🎯 Processing ${relevantFiles.length} relevant files (filtered from ${files.length})`);
+        // In test environment, fall back to sequential processing
+        // to avoid worker thread module loading issues
+        if (process.env.NODE_ENV === "test" || process.env.JEST_WORKER_ID) {
+            logger.verbose_log("Using fallback sequential processing in test environment");
+            // Import sequential processing functions
+            const { scanFiles, createProject, processFiles, } = require("./schema-processor");
+            const project = createProject(relevantFiles, tsconfigPath, logger);
+            const result = processFiles(project.getSourceFiles(), tsconfigPath, continueOnError, logger);
+            return result;
+        }
+        // Create worker tasks
+        const tasks = relevantFiles.map((file, index) => ({
+            id: `task-${index}-${path_1.default.basename(file)}`,
+            filePath: file,
+            tsconfigPath,
+        }));
+        // Process files using worker pool
+        const workerPool = new worker_pool_1.WorkerPool(logger, maxWorkers);
+        try {
+            const results = yield workerPool.processFiles(tasks);
+            // Aggregate results
+            for (const result of results) {
+                if (result.success) {
+                    contents.push(...result.contents);
+                    successCount += result.contents.length;
+                    if (result.contents.length > 0) {
+                        logger.verbose_log(`✅ Processed ${result.contents.length} definitions from ${result.id}`);
+                    }
+                }
+                else {
+                    failureCount++;
+                    const errorMessage = `❌ ${result.id} - ${result.error}`;
+                    errors.push(errorMessage);
+                    if (!continueOnError) {
+                        throw new Error(errorMessage);
+                    }
+                }
+            }
+            logger.success(`✅ Parallel processing completed: ${successCount} definitions from ${relevantFiles.length} files`);
+        }
+        catch (error) {
+            logger.error("Parallel processing failed:", error);
+            throw error;
+        }
+        return { contents, errors, successCount, failureCount };
+    });
+}
+// Pre-filter files to only process those likely to contain ATMYAPP exports
+function filterRelevantFiles(files, logger) {
+    return __awaiter(this, void 0, void 0, function* () {
+        logger.verbose_log("🔍 Pre-filtering files for ATMYAPP exports...");
+        const fs = require("fs").promises;
+        const relevantFiles = [];
+        // Process files in chunks for better performance
+        const chunkSize = 50;
+        const chunks = [];
+        for (let i = 0; i < files.length; i += chunkSize) {
+            chunks.push(files.slice(i, i + chunkSize));
+        }
+        for (const chunk of chunks) {
+            const chunkPromises = chunk.map((file) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    // 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)) {
+                        return file;
+                    }
+                    return null;
+                }
+                catch (error) {
+                    // Skip files that can't be read
+                    logger.verbose_log(`Skipping unreadable file: ${file}`);
+                    return null;
+                }
+            }));
+            const chunkResults = yield Promise.all(chunkPromises);
+            relevantFiles.push(...chunkResults.filter(Boolean));
+        }
+        logger.verbose_log(`📊 Filtered to ${relevantFiles.length} relevant files from ${files.length} total`);
+        return relevantFiles;
+    });
+}
+// Optimized file processing pipeline
+function optimizedMigrationPipeline(patterns, tsconfigPath, continueOnError, logger, maxWorkers) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Step 1: Scan files with optimization
+        const files = yield scanFilesOptimized(patterns, logger);
+        if (files.length === 0) {
+            logger.warn("No files found matching patterns");
+            return { contents: [], errors: [], successCount: 0, failureCount: 0 };
+        }
+        // Step 2: Process files in parallel
+        return yield processFilesParallel(files, tsconfigPath, continueOnError, logger, maxWorkers);
+    });
+}

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

@@ -124,9 +124,87 @@ function extractDefinitionTypes(atmyappType, logger) {
     }
     return elementTypes;
 }
+// Extract event information directly from TypeScript AST
+function extractEventInfoFromAST(file, definitionType, logger) {
+    try {
+        // Find the type alias declaration for this definition type
+        const typeAlias = file.getTypeAlias(definitionType);
+        if (!typeAlias) {
+            logger.verbose_log(`Could not find type alias for ${definitionType}`);
+            return null;
+        }
+        const typeNode = typeAlias.getTypeNode();
+        if (!typeNode) {
+            logger.verbose_log(`Type alias ${definitionType} has no type node`);
+            return null;
+        }
+        // Check if this is a type reference (like AmaCustomEventDef<...> or AmaEventDef<...>)
+        if (ts_morph_1.Node.isTypeReference(typeNode)) {
+            const typeName = typeNode.getTypeName();
+            const typeArguments = typeNode.getTypeArguments();
+            // Check if this is AmaCustomEventDef or AmaEventDef
+            if (ts_morph_1.Node.isIdentifier(typeName)) {
+                const typeNameText = typeName.getText();
+                if (typeNameText === "AmaCustomEventDef") {
+                    if (typeArguments.length >= 2) {
+                        // First argument should be the event ID (string literal)
+                        const idArg = typeArguments[0];
+                        let eventId = null;
+                        if (ts_morph_1.Node.isLiteralTypeNode(idArg)) {
+                            const literal = idArg.getLiteral();
+                            if (ts_morph_1.Node.isStringLiteral(literal)) {
+                                eventId = literal.getLiteralValue();
+                            }
+                        }
+                        // Second argument should be the columns (tuple of string literals)
+                        const columnsArg = typeArguments[1];
+                        let columns = [];
+                        if (ts_morph_1.Node.isTupleTypeNode(columnsArg)) {
+                            columnsArg.getElements().forEach((element) => {
+                                if (ts_morph_1.Node.isLiteralTypeNode(element)) {
+                                    const literal = element.getLiteral();
+                                    if (ts_morph_1.Node.isStringLiteral(literal)) {
+                                        columns.push(literal.getLiteralValue());
+                                    }
+                                }
+                            });
+                        }
+                        if (eventId && columns.length > 0) {
+                            logger.verbose_log(`AST extraction successful for ${definitionType}: id=${eventId}, columns=[${columns.join(", ")}]`);
+                            return { id: eventId, columns };
+                        }
+                    }
+                }
+                else if (typeNameText === "AmaEventDef") {
+                    // Handle AmaEventDef (basic events) - only has ID argument
+                    if (typeArguments.length >= 1) {
+                        const idArg = typeArguments[0];
+                        let eventId = null;
+                        if (ts_morph_1.Node.isLiteralTypeNode(idArg)) {
+                            const literal = idArg.getLiteral();
+                            if (ts_morph_1.Node.isStringLiteral(literal)) {
+                                eventId = literal.getLiteralValue();
+                            }
+                        }
+                        if (eventId) {
+                            logger.verbose_log(`AST extraction successful for basic event ${definitionType}: id=${eventId}`);
+                            return { id: eventId, columns: [] }; // Basic events have no predefined columns
+                        }
+                    }
+                }
+            }
+        }
+        logger.verbose_log(`Failed to extract event info from AST for ${definitionType}`);
+        return null;
+    }
+    catch (error) {
+        logger.verbose_log(`Error during AST extraction for ${definitionType}: ${error}`);
+        return null;
+    }
+}
 // Processes an ATMYAPP export to extract content definitions
 function processAtmyappExport(atmyappType, file, tsconfigPath, logger) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
     const contents = [];
     logger.verbose_log(`Processing ATMYAPP export in ${file.getFilePath()}`);
     // Extract individual definition types from the array
@@ -165,55 +243,99 @@ function processAtmyappExport(atmyappType, file, tsconfigPath, logger) {
                 continue;
             }
             if (!schema.properties) {
+                // For event definitions, the schema generator might fail due to generics
+                // Try to extract event information directly from the TypeScript AST
+                logger.verbose_log(`Schema has no properties. Attempting AST-based extraction for ${definitionType}`);
+                // Try to extract event definition from TypeScript AST
+                const eventInfo = extractEventInfoFromAST(file, definitionType, logger);
+                if (eventInfo) {
+                    logger.verbose_log(`Successfully extracted event via AST: ${eventInfo.id} with columns: ${eventInfo.columns.join(", ")}`);
+                    contents.push({
+                        path: eventInfo.id,
+                        structure: {
+                            type: "event",
+                            properties: {
+                                id: { const: eventInfo.id },
+                                columns: { const: eventInfo.columns },
+                                type: { const: "event" },
+                            },
+                        },
+                    });
+                    continue;
+                }
                 logger.warn(`Invalid schema structure for ${definitionType}`);
                 continue;
             }
             const properties = schema.properties;
+            // Debug: Log the actual schema structure
+            logger.verbose_log(`Schema for ${definitionType}: ${JSON.stringify(properties, null, 2)}`);
             // Check if this is an event definition
             const isEventDef = ((_a = properties.type) === null || _a === void 0 ? void 0 : _a.const) === "event" ||
-                (((_b = properties.__is_ATMYAPP_Object) === null || _b === void 0 ? void 0 : _b.const) === true &&
+                ((_b = properties.type) === null || _b === void 0 ? void 0 : _b.const) === "basic_event" ||
+                (((_c = properties.__is_ATMYAPP_Object) === null || _c === void 0 ? void 0 : _c.const) === true &&
                     properties.id &&
-                    properties.columns);
+                    (properties.columns || ((_d = properties.type) === null || _d === void 0 ? void 0 : _d.const) === "basic_event"));
             if (isEventDef) {
-                // Handle AmaEventDef - use id as path and extract event structure
+                // Handle AmaCustomEventDef and AmaEventDef - use id as path and extract event structure
                 let eventId = null;
                 let columns = [];
-                // Extract event ID
-                if ((_c = properties.id) === null || _c === void 0 ? void 0 : _c.const) {
+                // Extract event ID - try different possible structures
+                if ((_e = properties.id) === null || _e === void 0 ? void 0 : _e.const) {
                     eventId = properties.id.const;
                 }
-                // Extract columns
-                if ((_d = properties.columns) === null || _d === void 0 ? void 0 : _d.const) {
+                else if (((_f = properties.id) === null || _f === void 0 ? void 0 : _f.enum) && properties.id.enum.length === 1) {
+                    eventId = properties.id.enum[0];
+                }
+                else if (((_g = properties.id) === null || _g === void 0 ? void 0 : _g.type) === "string" && ((_h = properties.id) === null || _h === void 0 ? void 0 : _h.title)) {
+                    // Fallback: try to extract from title or other metadata
+                    eventId = properties.id.title;
+                }
+                // Extract columns - try different possible structures
+                // For basic events, columns might not exist (they use Record<string, string>)
+                if ((_j = properties.columns) === null || _j === void 0 ? void 0 : _j.const) {
                     columns = properties.columns.const;
                 }
-                else if ((_f = (_e = properties.columns) === null || _e === void 0 ? void 0 : _e.items) === null || _f === void 0 ? void 0 : _f.const) {
+                else if ((_l = (_k = properties.columns) === null || _k === void 0 ? void 0 : _k.items) === null || _l === void 0 ? void 0 : _l.const) {
                     columns = properties.columns.items.const;
                 }
-                else if (((_g = properties.columns) === null || _g === void 0 ? void 0 : _g.items) &&
+                else if (((_m = properties.columns) === null || _m === void 0 ? void 0 : _m.items) &&
                     Array.isArray(properties.columns.items)) {
                     // Handle array of const items - extract const value from each item
                     columns = properties.columns.items
                         .map((item) => item.const)
                         .filter(Boolean);
                 }
+                else if ((_p = (_o = properties.columns) === null || _o === void 0 ? void 0 : _o.items) === null || _p === void 0 ? void 0 : _p.enum) {
+                    // Handle tuple type where each position has enum with single value
+                    columns = properties.columns.items.enum;
+                }
+                else if (((_q = properties.columns) === null || _q === void 0 ? void 0 : _q.enum) &&
+                    Array.isArray(properties.columns.enum[0])) {
+                    // Handle case where columns is an enum with array values
+                    columns = properties.columns.enum[0];
+                }
+                // Debug: Log what we extracted
+                logger.verbose_log(`Extracted from ${definitionType}: eventId=${eventId}, columns=${JSON.stringify(columns)}`);
                 if (!eventId) {
                     logger.warn(`Could not extract event ID from ${definitionType}`);
                     continue;
                 }
-                if (columns.length === 0) {
+                // For basic events, empty columns array is acceptable
+                const isBasicEvent = ((_r = properties.type) === null || _r === void 0 ? void 0 : _r.const) === "basic_event";
+                if (columns.length === 0 && !isBasicEvent) {
                     logger.warn(`Could not extract columns from ${definitionType}`);
                     continue;
                 }
-                logger.verbose_log(`Successfully extracted event: ${eventId} with columns: ${columns.join(", ")}`);
+                logger.verbose_log(`Successfully extracted ${isBasicEvent ? "basic " : ""}event: ${eventId}${columns.length > 0 ? ` with columns: ${columns.join(", ")}` : ""}`);
                 // Create event content with special structure
                 contents.push({
                     path: eventId, // Use event ID as path
                     structure: {
-                        type: "event",
+                        type: isBasicEvent ? "basic_event" : "event",
                         properties: {
                             id: { const: eventId },
                             columns: { const: columns },
-                            type: { const: "event" },
+                            type: { const: isBasicEvent ? "basic_event" : "event" },
                         },
                     },
                 });
@@ -223,10 +345,10 @@ function processAtmyappExport(atmyappType, file, tsconfigPath, logger) {
                 let path = null;
                 let structure = null;
                 // Look for path in different possible locations
-                if ((_h = properties.path) === null || _h === void 0 ? void 0 : _h.const) {
+                if ((_s = properties.path) === null || _s === void 0 ? void 0 : _s.const) {
                     path = properties.path.const;
                 }
-                else if ((_j = properties._path) === null || _j === void 0 ? void 0 : _j.const) {
+                else if ((_t = properties._path) === null || _t === void 0 ? void 0 : _t.const) {
                     path = properties._path.const;
                 }
                 // Look for structure/data in different possible locations

package/dist/cli/utils/worker-file-processor.d.ts

@@ -0,0 +1,7 @@
+interface FileContent {
+    path: string;
+    structure: any;
+    type?: string;
+}
+export declare function processFileInWorker(filePath: string, tsconfigPath: string): Promise<FileContent[]>;
+export {};

package/dist/cli/utils/worker-file-processor.js

@@ -0,0 +1,255 @@
+"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.processFileInWorker = processFileInWorker;
+const ts_morph_1 = require("ts-morph");
+const ts = __importStar(require("typescript"));
+const path_1 = require("path");
+const typescript_json_schema_1 = require("typescript-json-schema");
+const fs_1 = require("fs");
+// Cache for TypeScript programs to avoid recompilation
+const programCache = new Map();
+// Optimized function to process a single file in a worker
+function processFileInWorker(filePath, tsconfigPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const contents = [];
+        // Create or reuse TypeScript project
+        const resolvedTsConfigPath = (0, path_1.resolve)(process.cwd(), tsconfigPath);
+        const projectOptions = {
+            tsConfigFilePath: (0, fs_1.existsSync)(resolvedTsConfigPath)
+                ? resolvedTsConfigPath
+                : undefined,
+            skipAddingFilesFromTsConfig: true,
+            compilerOptions: !(0, fs_1.existsSync)(resolvedTsConfigPath)
+                ? {
+                    target: ts.ScriptTarget.ESNext,
+                    module: ts.ModuleKind.ESNext,
+                    moduleResolution: ts.ModuleResolutionKind.NodeJs,
+                    esModuleInterop: true,
+                    jsx: ts.JsxEmit.React,
+                    skipLibCheck: true,
+                }
+                : undefined,
+        };
+        const project = new ts_morph_1.Project(projectOptions);
+        const sourceFile = project.addSourceFileAtPath(filePath);
+        // Look for ATMYAPP exports
+        const atmyappExports = sourceFile.getTypeAliases().filter((alias) => {
+            const name = alias.getName();
+            const isExported = alias.isExported();
+            return name === "ATMYAPP" && isExported;
+        });
+        if (atmyappExports.length === 0) {
+            return contents;
+        }
+        // Process each ATMYAPP export
+        for (const atmyappExport of atmyappExports) {
+            const fileContents = yield processAtmyappExportOptimized(atmyappExport, sourceFile, tsconfigPath);
+            contents.push(...fileContents);
+        }
+        return contents;
+    });
+}
+// Optimized version that reuses TypeScript programs
+function processAtmyappExportOptimized(atmyappType, file, tsconfigPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        const contents = [];
+        const filePath = file.getFilePath();
+        // Extract definition types
+        const definitionTypes = extractDefinitionTypes(atmyappType);
+        if (definitionTypes.length === 0) {
+            return contents;
+        }
+        // Create or reuse TypeScript program
+        const resolvedTsConfigPath = (0, path_1.resolve)(process.cwd(), tsconfigPath);
+        const cacheKey = `${filePath}:${resolvedTsConfigPath}`;
+        let program = programCache.get(cacheKey);
+        if (!program) {
+            const compilerOptions = (0, fs_1.existsSync)(resolvedTsConfigPath)
+                ? { configFile: resolvedTsConfigPath }
+                : {
+                    target: ts.ScriptTarget.ES2015,
+                    module: ts.ModuleKind.ESNext,
+                    strict: true,
+                    esModuleInterop: true,
+                    skipLibCheck: true,
+                    jsx: ts.JsxEmit.Preserve,
+                };
+            program = (0, typescript_json_schema_1.getProgramFromFiles)([filePath], compilerOptions);
+            programCache.set(cacheKey, program);
+        }
+        // Batch process all definition types for this file
+        const schemaPromises = definitionTypes.map((definitionType) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const schema = (0, typescript_json_schema_1.generateSchema)(program, definitionType, {
+                    required: true,
+                    noExtraProps: true,
+                    aliasRef: true,
+                    ref: false,
+                    defaultNumberType: "number",
+                    ignoreErrors: true,
+                    skipLibCheck: true,
+                });
+                return { definitionType, schema };
+            }
+            catch (error) {
+                return { definitionType, schema: null, error };
+            }
+        }));
+        const schemaResults = yield Promise.all(schemaPromises);
+        // Process schema results
+        for (const result of schemaResults) {
+            if (!result.schema || !result.schema.properties) {
+                continue;
+            }
+            const properties = result.schema.properties;
+            const isEventDef = ((_a = properties.type) === null || _a === void 0 ? void 0 : _a.const) === "event" ||
+                ((_b = properties.type) === null || _b === void 0 ? void 0 : _b.const) === "basic_event" ||
+                (((_c = properties.__is_ATMYAPP_Object) === null || _c === void 0 ? void 0 : _c.const) === true &&
+                    properties.id &&
+                    (properties.columns || ((_d = properties.type) === null || _d === void 0 ? void 0 : _d.const) === "basic_event"));
+            if (isEventDef) {
+                // Handle event definitions
+                const eventContent = processEventDefinition(properties, result.definitionType);
+                if (eventContent) {
+                    contents.push(eventContent);
+                }
+            }
+            else {
+                // Handle regular content definitions
+                const contentDefinition = processContentDefinition(properties, result.definitionType);
+                if (contentDefinition) {
+                    contents.push(contentDefinition);
+                }
+            }
+        }
+        return contents;
+    });
+}
+function extractDefinitionTypes(atmyappType) {
+    const typeNode = atmyappType.getTypeNode();
+    if (!ts_morph_1.Node.isTupleTypeNode(typeNode) && !ts_morph_1.Node.isArrayTypeNode(typeNode)) {
+        return [];
+    }
+    const elementTypes = [];
+    if (ts_morph_1.Node.isTupleTypeNode(typeNode)) {
+        typeNode.getElements().forEach((element) => {
+            elementTypes.push(element.getText());
+        });
+    }
+    else if (ts_morph_1.Node.isArrayTypeNode(typeNode)) {
+        elementTypes.push(typeNode.getElementTypeNode().getText());
+    }
+    return elementTypes;
+}
+function processEventDefinition(properties, definitionType) {
+    var _a, _b, _c, _d, _e, _f;
+    let eventId = null;
+    let columns = [];
+    // Extract event ID
+    if ((_a = properties.id) === null || _a === void 0 ? void 0 : _a.const) {
+        eventId = properties.id.const;
+    }
+    // Extract columns (may be empty for basic events)
+    if ((_b = properties.columns) === null || _b === void 0 ? void 0 : _b.const) {
+        columns = properties.columns.const;
+    }
+    else if ((_d = (_c = properties.columns) === null || _c === void 0 ? void 0 : _c.items) === null || _d === void 0 ? void 0 : _d.const) {
+        columns = properties.columns.items.const;
+    }
+    else if (((_e = properties.columns) === null || _e === void 0 ? void 0 : _e.items) &&
+        Array.isArray(properties.columns.items)) {
+        columns = properties.columns.items
+            .map((item) => item.const)
+            .filter(Boolean);
+    }
+    // Check if this is a basic event
+    const isBasicEvent = ((_f = properties.type) === null || _f === void 0 ? void 0 : _f.const) === "basic_event";
+    // For basic events, we don't require columns, but we still need an event ID
+    if (!eventId) {
+        return null;
+    }
+    // For custom events, we require columns, but for basic events columns can be empty
+    if (!isBasicEvent && columns.length === 0) {
+        return null;
+    }
+    return {
+        path: eventId,
+        structure: {
+            type: isBasicEvent ? "basic_event" : "event",
+            properties: {
+                id: { const: eventId },
+                columns: { const: columns },
+                type: { const: isBasicEvent ? "basic_event" : "event" },
+            },
+        },
+    };
+}
+function processContentDefinition(properties, definitionType) {
+    var _a, _b;
+    let path = null;
+    let structure = null;
+    // Extract path
+    if ((_a = properties.path) === null || _a === void 0 ? void 0 : _a.const) {
+        path = properties.path.const;
+    }
+    else if ((_b = properties._path) === null || _b === void 0 ? void 0 : _b.const) {
+        path = properties._path.const;
+    }
+    // Extract structure
+    if (properties.structure) {
+        structure = properties.structure;
+    }
+    else if (properties.data) {
+        structure = properties.data;
+    }
+    else if (properties._data) {
+        structure = properties._data;
+    }
+    if (!path || !structure) {
+        return null;
+    }
+    return { path, structure };
+}

package/dist/cli/utils/worker-pool.d.ts

@@ -0,0 +1,25 @@
+import { Logger } from "../logger";
+export interface WorkerTask {
+    id: string;
+    filePath: string;
+    tsconfigPath: string;
+}
+export interface WorkerResult {
+    id: string;
+    success: boolean;
+    contents: any[];
+    error?: string;
+}
+export declare class WorkerPool {
+    private workers;
+    private taskQueue;
+    private activeWorkers;
+    private results;
+    private logger;
+    private maxWorkers;
+    constructor(logger: Logger, maxWorkers?: number);
+    processFiles(tasks: WorkerTask[]): Promise<WorkerResult[]>;
+    private setupWorker;
+    private assignNextTask;
+    private cleanup;
+}