@mondaydotcomorg/atp-compiler 0.17.14

package/src/runtime/resumable-arrays.ts

@@ -0,0 +1,253 @@
+import { getCheckpointManager } from './checkpoint-manager.js';
+import type { LoopCheckpoint } from '../types.js';
+import { InfiniteLoopDetectionError } from './errors.js';
+
+const MAX_ITERATIONS = 1000000;
+
+export async function resumableMap<T, R>(
+	items: T[],
+	callback: (item: T, index: number, array: T[]) => Promise<R>,
+	mapId: string
+): Promise<R[]> {
+	const checkpointManager = getCheckpointManager();
+	const checkpoint = await checkpointManager.load(mapId);
+	const startIndex = checkpoint?.currentIndex || 0;
+	const results = (checkpoint?.results as R[]) || [];
+
+	for (let i = startIndex; i < items.length; i++) {
+		if (i > MAX_ITERATIONS) {
+			throw new InfiniteLoopDetectionError(mapId, i);
+		}
+
+		results[i] = await callback(items[i]!, i, items);
+
+		const newCheckpoint: LoopCheckpoint = {
+			loopId: mapId,
+			currentIndex: i + 1,
+			results: results,
+			timestamp: Date.now(),
+		};
+		await checkpointManager.save(newCheckpoint);
+	}
+
+	await checkpointManager.clear(mapId);
+	return results;
+}
+
+export async function resumableForEach<T>(
+	items: T[],
+	callback: (item: T, index: number, array: T[]) => Promise<void>,
+	forEachId: string
+): Promise<void> {
+	const checkpointManager = getCheckpointManager();
+	const checkpoint = await checkpointManager.load(forEachId);
+	const startIndex = checkpoint?.currentIndex || 0;
+
+	for (let i = startIndex; i < items.length; i++) {
+		if (i > MAX_ITERATIONS) {
+			throw new InfiniteLoopDetectionError(forEachId, i);
+		}
+
+		await callback(items[i]!, i, items);
+
+		const newCheckpoint: LoopCheckpoint = {
+			loopId: forEachId,
+			currentIndex: i + 1,
+			timestamp: Date.now(),
+		};
+		await checkpointManager.save(newCheckpoint);
+	}
+
+	await checkpointManager.clear(forEachId);
+}
+
+export async function resumableFilter<T>(
+	items: T[],
+	callback: (item: T, index: number, array: T[]) => Promise<boolean>,
+	filterId: string
+): Promise<T[]> {
+	const checkpointManager = getCheckpointManager();
+	const checkpoint = await checkpointManager.load(filterId);
+	const startIndex = checkpoint?.currentIndex || 0;
+	const results = (checkpoint?.results as T[]) || [];
+
+	for (let i = startIndex; i < items.length; i++) {
+		if (i > MAX_ITERATIONS) {
+			throw new InfiniteLoopDetectionError(filterId, i);
+		}
+
+		const passed = await callback(items[i]!, i, items);
+		if (passed) {
+			results.push(items[i]!);
+		}
+
+		const newCheckpoint: LoopCheckpoint = {
+			loopId: filterId,
+			currentIndex: i + 1,
+			results: results,
+			timestamp: Date.now(),
+		};
+		await checkpointManager.save(newCheckpoint);
+	}
+
+	await checkpointManager.clear(filterId);
+	return results;
+}
+
+export async function resumableReduce<T, R>(
+	items: T[],
+	callback: (accumulator: R, item: T, index: number, array: T[]) => Promise<R>,
+	initialValue: R,
+	reduceId: string
+): Promise<R> {
+	const checkpointManager = getCheckpointManager();
+	const checkpoint = await checkpointManager.load(reduceId);
+	const startIndex = checkpoint?.currentIndex || 0;
+	let accumulator = (checkpoint?.accumulator as R) ?? initialValue;
+
+	for (let i = startIndex; i < items.length; i++) {
+		if (i > MAX_ITERATIONS) {
+			throw new InfiniteLoopDetectionError(reduceId, i);
+		}
+
+		accumulator = await callback(accumulator, items[i]!, i, items);
+
+		const newCheckpoint: LoopCheckpoint = {
+			loopId: reduceId,
+			currentIndex: i + 1,
+			accumulator: accumulator,
+			timestamp: Date.now(),
+		};
+		await checkpointManager.save(newCheckpoint);
+	}
+
+	await checkpointManager.clear(reduceId);
+	return accumulator;
+}
+
+export async function resumableFind<T>(
+	items: T[],
+	callback: (item: T, index: number, array: T[]) => Promise<boolean>,
+	findId: string
+): Promise<T | undefined> {
+	const checkpointManager = getCheckpointManager();
+	const checkpoint = await checkpointManager.load(findId);
+	const startIndex = checkpoint?.currentIndex || 0;
+
+	for (let i = startIndex; i < items.length; i++) {
+		if (i > MAX_ITERATIONS) {
+			throw new InfiniteLoopDetectionError(findId, i);
+		}
+
+		const found = await callback(items[i]!, i, items);
+		if (found) {
+			await checkpointManager.clear(findId);
+			return items[i];
+		}
+
+		const newCheckpoint: LoopCheckpoint = {
+			loopId: findId,
+			currentIndex: i + 1,
+			timestamp: Date.now(),
+		};
+		await checkpointManager.save(newCheckpoint);
+	}
+
+	await checkpointManager.clear(findId);
+	return undefined;
+}
+
+export async function resumableSome<T>(
+	items: T[],
+	callback: (item: T, index: number, array: T[]) => Promise<boolean>,
+	someId: string
+): Promise<boolean> {
+	const checkpointManager = getCheckpointManager();
+	const checkpoint = await checkpointManager.load(someId);
+	const startIndex = checkpoint?.currentIndex || 0;
+
+	for (let i = startIndex; i < items.length; i++) {
+		if (i > MAX_ITERATIONS) {
+			throw new InfiniteLoopDetectionError(someId, i);
+		}
+
+		const result = await callback(items[i]!, i, items);
+		if (result) {
+			await checkpointManager.clear(someId);
+			return true;
+		}
+
+		const newCheckpoint: LoopCheckpoint = {
+			loopId: someId,
+			currentIndex: i + 1,
+			timestamp: Date.now(),
+		};
+		await checkpointManager.save(newCheckpoint);
+	}
+
+	await checkpointManager.clear(someId);
+	return false;
+}
+
+export async function resumableEvery<T>(
+	items: T[],
+	callback: (item: T, index: number, array: T[]) => Promise<boolean>,
+	everyId: string
+): Promise<boolean> {
+	const checkpointManager = getCheckpointManager();
+	const checkpoint = await checkpointManager.load(everyId);
+	const startIndex = checkpoint?.currentIndex || 0;
+
+	for (let i = startIndex; i < items.length; i++) {
+		if (i > MAX_ITERATIONS) {
+			throw new InfiniteLoopDetectionError(everyId, i);
+		}
+
+		const result = await callback(items[i]!, i, items);
+		if (!result) {
+			await checkpointManager.clear(everyId);
+			return false;
+		}
+
+		const newCheckpoint: LoopCheckpoint = {
+			loopId: everyId,
+			currentIndex: i + 1,
+			timestamp: Date.now(),
+		};
+		await checkpointManager.save(newCheckpoint);
+	}
+
+	await checkpointManager.clear(everyId);
+	return true;
+}
+
+export async function resumableFlatMap<T, R>(
+	items: T[],
+	callback: (item: T, index: number, array: T[]) => Promise<R[]>,
+	flatMapId: string
+): Promise<R[]> {
+	const checkpointManager = getCheckpointManager();
+	const checkpoint = await checkpointManager.load(flatMapId);
+	const startIndex = checkpoint?.currentIndex || 0;
+	const results = (checkpoint?.results as R[]) || [];
+
+	for (let i = startIndex; i < items.length; i++) {
+		if (i > MAX_ITERATIONS) {
+			throw new InfiniteLoopDetectionError(flatMapId, i);
+		}
+
+		const mapped = await callback(items[i]!, i, items);
+		results.push(...mapped);
+
+		const newCheckpoint: LoopCheckpoint = {
+			loopId: flatMapId,
+			currentIndex: i + 1,
+			results: results,
+			timestamp: Date.now(),
+		};
+		await checkpointManager.save(newCheckpoint);
+	}
+
+	await checkpointManager.clear(flatMapId);
+	return results;
+}

package/src/runtime/resumable-loops.ts

@@ -0,0 +1,93 @@
+import { getCheckpointManager } from './checkpoint-manager.js';
+import type { LoopCheckpoint } from '../types.js';
+import { InfiniteLoopDetectionError } from './errors.js';
+
+const MAX_ITERATIONS = 1000000;
+
+export async function resumableForOf<T>(
+	items: T[],
+	callback: (item: T, index: number) => Promise<void>,
+	loopId: string
+): Promise<void> {
+	const checkpointManager = getCheckpointManager();
+	const checkpoint = await checkpointManager.load(loopId);
+	const startIndex = checkpoint?.currentIndex || 0;
+
+	for (let i = startIndex; i < items.length; i++) {
+		if (i > MAX_ITERATIONS) {
+			throw new InfiniteLoopDetectionError(loopId, i);
+		}
+
+		await callback(items[i]!, i);
+
+		const newCheckpoint: LoopCheckpoint = {
+			loopId,
+			currentIndex: i + 1,
+			timestamp: Date.now(),
+		};
+		await checkpointManager.save(newCheckpoint);
+	}
+
+	await checkpointManager.clear(loopId);
+}
+
+export async function resumableWhile(
+	conditionFn: () => boolean | Promise<boolean>,
+	bodyFn: (iteration: number) => Promise<void>,
+	loopId: string
+): Promise<void> {
+	const checkpointManager = getCheckpointManager();
+	const checkpoint = await checkpointManager.load(loopId);
+	let iteration = checkpoint?.currentIndex || 0;
+
+	while (await Promise.resolve(conditionFn())) {
+		if (iteration > MAX_ITERATIONS) {
+			throw new InfiniteLoopDetectionError(loopId, iteration);
+		}
+
+		await bodyFn(iteration);
+
+		const newCheckpoint: LoopCheckpoint = {
+			loopId,
+			currentIndex: iteration + 1,
+			timestamp: Date.now(),
+		};
+		await checkpointManager.save(newCheckpoint);
+
+		iteration++;
+	}
+
+	await checkpointManager.clear(loopId);
+}
+
+export async function resumableForLoop(
+	initValue: number,
+	conditionFn: (i: number) => boolean,
+	incrementFn: (i: number) => number,
+	bodyFn: (i: number) => Promise<void>,
+	loopId: string
+): Promise<void> {
+	const checkpointManager = getCheckpointManager();
+	const checkpoint = await checkpointManager.load(loopId);
+	let i = checkpoint?.currentIndex !== undefined ? checkpoint.currentIndex : initValue;
+
+	let iterations = 0;
+	while (conditionFn(i)) {
+		if (iterations++ > MAX_ITERATIONS) {
+			throw new InfiniteLoopDetectionError(loopId, iterations);
+		}
+
+		await bodyFn(i);
+
+		const newCheckpoint: LoopCheckpoint = {
+			loopId,
+			currentIndex: incrementFn(i),
+			timestamp: Date.now(),
+		};
+		await checkpointManager.save(newCheckpoint);
+
+		i = incrementFn(i);
+	}
+
+	await checkpointManager.clear(loopId);
+}

package/src/runtime/resumable-parallel.ts

@@ -0,0 +1,57 @@
+import { getCheckpointManager } from './checkpoint-manager.js';
+import type { LoopCheckpoint } from '../types.js';
+
+export async function resumablePromiseAll<T>(
+	promises: Promise<T>[],
+	parallelId: string
+): Promise<T[]> {
+	const checkpointManager = getCheckpointManager();
+	const checkpoint = await checkpointManager.load(parallelId);
+	const startIndex = checkpoint?.currentIndex || 0;
+	const results = (checkpoint?.results as T[]) || [];
+
+	for (let i = startIndex; i < promises.length; i++) {
+		results[i] = (await promises[i]) as T;
+
+		const newCheckpoint: LoopCheckpoint = {
+			loopId: parallelId,
+			currentIndex: i + 1,
+			results: results,
+			timestamp: Date.now(),
+		};
+		await checkpointManager.save(newCheckpoint);
+	}
+
+	await checkpointManager.clear(parallelId);
+	return results;
+}
+
+export async function resumablePromiseAllSettled<T>(
+	promises: Promise<T>[],
+	parallelId: string
+): Promise<PromiseSettledResult<T>[]> {
+	const checkpointManager = getCheckpointManager();
+	const checkpoint = await checkpointManager.load(parallelId);
+	const startIndex = checkpoint?.currentIndex || 0;
+	const results = (checkpoint?.results as PromiseSettledResult<T>[]) || [];
+
+	for (let i = startIndex; i < promises.length; i++) {
+		try {
+			const value = (await promises[i]) as T;
+			results[i] = { status: 'fulfilled', value };
+		} catch (reason) {
+			results[i] = { status: 'rejected', reason };
+		}
+
+		const newCheckpoint: LoopCheckpoint = {
+			loopId: parallelId,
+			currentIndex: i + 1,
+			results: results,
+			timestamp: Date.now(),
+		};
+		await checkpointManager.save(newCheckpoint);
+	}
+
+	await checkpointManager.clear(parallelId);
+	return results;
+}

package/src/transformer/array-transformer-batch.ts

@@ -0,0 +1,86 @@
+import * as t from '@babel/types';
+import { generateUniqueId } from '../runtime/context.js';
+import { BatchParallelDetector } from './batch-detector.js';
+import { findLLMCallExpression } from './array-transformer-utils.js';
+import { wrapBatchResultIfNeeded } from './array-transformer-wrappers.js';
+
+/**
+ * Extract batch call info from callback
+ */
+export function extractBatchCallInfo(
+	callback: t.Function,
+	batchDetector: BatchParallelDetector
+): {
+	mapperFunction: t.ArrowFunctionExpression;
+} | null {
+	const paramName = callback.params[0];
+	if (!t.isIdentifier(paramName)) {
+		return null;
+	}
+
+	const param = paramName.name;
+
+	const llmCall = findLLMCallExpression(callback.body);
+	if (!llmCall) {
+		return null;
+	}
+
+	const callInfo = batchDetector.extractCallInfo(llmCall);
+	if (!callInfo) {
+		return null;
+	}
+
+	const payloadNode = batchDetector.extractPayloadNode(llmCall);
+	if (!payloadNode) {
+		return null;
+	}
+
+	const mapperFunction = t.arrowFunctionExpression(
+		[t.identifier(param)],
+		t.objectExpression([
+			t.objectProperty(t.identifier('type'), t.stringLiteral(callInfo.type)),
+			t.objectProperty(t.identifier('operation'), t.stringLiteral(callInfo.operation)),
+			t.objectProperty(t.identifier('payload'), payloadNode),
+		])
+	);
+
+	return { mapperFunction };
+}
+
+/**
+ * Transform simple array method to batch parallel execution
+ */
+export function transformToBatchParallel(
+	path: any,
+	node: t.CallExpression,
+	methodName: string,
+	callback: t.Function,
+	batchDetector: BatchParallelDetector,
+	onTransform: () => void,
+	fallbackTransform: () => boolean
+): boolean {
+	const methodId = generateUniqueId(`${methodName}_batch`);
+	const array = (node.callee as t.MemberExpression).object;
+
+	const callInfo = extractBatchCallInfo(callback, batchDetector);
+	if (!callInfo) {
+		return fallbackTransform();
+	}
+
+	const batchCallsArray = t.callExpression(t.memberExpression(array, t.identifier('map')), [
+		callInfo.mapperFunction,
+	]);
+
+	const batchCall = t.awaitExpression(
+		t.callExpression(t.memberExpression(t.identifier('__runtime'), t.identifier('batchParallel')), [
+			batchCallsArray,
+			t.stringLiteral(methodId),
+		])
+	);
+
+	const finalCall = wrapBatchResultIfNeeded(batchCall, methodName, array, methodId);
+
+	path.replaceWith(finalCall);
+	onTransform();
+	return true;
+}

package/src/transformer/array-transformer-sequential.ts

@@ -0,0 +1,38 @@
+import * as t from '@babel/types';
+import { generateUniqueId } from '../runtime/context.js';
+import { getRuntimeMethodName } from './array-transformer-utils.js';
+
+/**
+ * Transform to sequential execution with checkpoints (fallback)
+ */
+export function transformToSequential(
+	path: any,
+	node: t.CallExpression,
+	methodName: string,
+	callback: t.Function,
+	onTransform: () => void
+): boolean {
+	const runtimeMethod = getRuntimeMethodName(methodName);
+	if (!runtimeMethod) {
+		return false;
+	}
+
+	const methodId = generateUniqueId(methodName);
+	const array = (node.callee as t.MemberExpression).object;
+	const args: t.Expression[] = [array, callback as t.Expression, t.stringLiteral(methodId)];
+
+	if (methodName === 'reduce' && node.arguments[1]) {
+		args.push(node.arguments[1] as t.Expression);
+	}
+
+	const runtimeCall = t.awaitExpression(
+		t.callExpression(
+			t.memberExpression(t.identifier('__runtime'), t.identifier(runtimeMethod)),
+			args
+		)
+	);
+
+	path.replaceWith(runtimeCall);
+	onTransform();
+	return true;
+}

package/src/transformer/array-transformer-utils.ts

@@ -0,0 +1,80 @@
+import * as t from '@babel/types';
+
+/**
+ * Find LLM call expression in callback body
+ */
+export function findLLMCallExpression(
+	body: t.BlockStatement | t.Expression
+): t.CallExpression | null {
+	let found: t.CallExpression | null = null;
+
+	const visit = (node: t.Node) => {
+		if (found) return;
+
+		if (t.isAwaitExpression(node) && t.isCallExpression(node.argument)) {
+			const call = node.argument;
+			if (t.isMemberExpression(call.callee)) {
+				found = call;
+				return;
+			}
+		}
+
+		Object.keys(node).forEach((key) => {
+			const value = (node as any)[key];
+			if (Array.isArray(value)) {
+				value.forEach((item) => {
+					if (item && typeof item === 'object' && item.type) {
+						visit(item);
+					}
+				});
+			} else if (value && typeof value === 'object' && value.type) {
+				visit(value);
+			}
+		});
+	};
+
+	visit(body);
+	return found;
+}
+
+/**
+ * Get array method name from call expression
+ */
+export function getArrayMethodName(node: t.CallExpression): string | null {
+	const arrayMethods = ['map', 'forEach', 'filter', 'reduce', 'find', 'some', 'every', 'flatMap'];
+
+	const { isArrayMethod } = require('./utils.js');
+
+	for (const method of arrayMethods) {
+		if (isArrayMethod(node, method)) {
+			return method;
+		}
+	}
+
+	return null;
+}
+
+/**
+ * Get runtime method name for array method
+ */
+export function getRuntimeMethodName(arrayMethod: string): string | null {
+	const mapping: Record<string, string> = {
+		map: 'resumableMap',
+		forEach: 'resumableForEach',
+		filter: 'resumableFilter',
+		reduce: 'resumableReduce',
+		find: 'resumableFind',
+		some: 'resumableSome',
+		every: 'resumableEvery',
+		flatMap: 'resumableFlatMap',
+	};
+
+	return mapping[arrayMethod] || null;
+}
+
+/**
+ * Check if method can use batch parallel optimization
+ */
+export function canUseBatchParallel(methodName: string): boolean {
+	return ['map', 'forEach', 'filter', 'find', 'some', 'every'].includes(methodName);
+}