@mondaydotcomorg/atp-compiler 0.17.14

package/__tests__/unit/batch-optimizer.test.ts

@@ -0,0 +1,253 @@
+/**
+ * Tests for Batch Optimizer
+ *
+ * Verifies that simple callbacks are correctly identified as batchable
+ * and complex callbacks fall back to sequential execution
+ */
+
+import { describe, test, expect } from '@jest/globals';
+import * as parser from '@babel/parser';
+import * as t from '@babel/types';
+import { BatchOptimizer } from '../../src/transformer/batch-optimizer';
+
+describe('BatchOptimizer', () => {
+	const optimizer = new BatchOptimizer();
+
+	describe('canBatchArrayMethod', () => {
+		test('✅ Simple forEach with single LLM call - CAN BATCH', () => {
+			const code = `async (item) => { await atp.llm.call({ prompt: item }); }`;
+			const ast = parser.parseExpression(code);
+			const callback = ast as t.Function;
+
+			const result = optimizer.canBatchArrayMethod(callback);
+
+			expect(result.canBatch).toBe(true);
+			expect(result.llmCallPattern).toBe('single');
+		});
+
+		test('✅ Simple map with single LLM call - CAN BATCH', () => {
+			const code = `async (item) => await atp.llm.call({ prompt: item })`;
+			const ast = parser.parseExpression(code);
+			const callback = ast as t.Function;
+
+			const result = optimizer.canBatchArrayMethod(callback);
+
+			expect(result.canBatch).toBe(true);
+			expect(result.llmCallPattern).toBe('single');
+		});
+
+		test('✅ Arrow function with expression body - CAN BATCH', () => {
+			const code = `async (x) => await atp.llm.call({ prompt: x })`;
+			const ast = parser.parseExpression(code);
+			const callback = ast as t.Function;
+
+			const result = optimizer.canBatchArrayMethod(callback);
+
+			expect(result.canBatch).toBe(true);
+		});
+
+		test('✅ forEach with conditional - CAN BATCH (smart decision later)', () => {
+			const code = `async (item) => { 
+        if (item.priority > 5) {
+          await atp.llm.call({ prompt: item });
+        }
+      }`;
+			const ast = parser.parseExpression(code);
+			const callback = ast as t.Function;
+
+			const result = optimizer.canBatchArrayMethod(callback);
+
+			expect(result.canBatch).toBe(true);
+			expect(result.hasConditionals).toBe(true);
+			expect(result.llmCallPattern).toBe('conditional');
+		});
+
+		test('❌ forEach with loop inside - CANNOT BATCH', () => {
+			const code = `async (item) => { 
+        for (const x of item.parts) {
+          await atp.llm.call({ prompt: x });
+        }
+      }`;
+			const ast = parser.parseExpression(code);
+			const callback = ast as t.Function;
+
+			const result = optimizer.canBatchArrayMethod(callback);
+
+			expect(result.canBatch).toBe(false);
+			expect(result.reason).toBe('Contains loops');
+		});
+
+		test('❌ forEach with try-catch - CANNOT BATCH', () => {
+			const code = `async (item) => { 
+        try {
+          await atp.llm.call({ prompt: item });
+        } catch (e) {
+          console.error(e);
+        }
+      }`;
+			const ast = parser.parseExpression(code);
+			const callback = ast as t.Function;
+
+			const result = optimizer.canBatchArrayMethod(callback);
+
+			expect(result.canBatch).toBe(false);
+			expect(result.reason).toBe('Contains try-catch');
+		});
+
+		test('❌ forEach with sequential dependencies - CANNOT BATCH', () => {
+			const code = `async (item) => { 
+        const first = await atp.llm.call({ prompt: item });
+        const second = await atp.llm.call({ prompt: first });
+        return second;
+      }`;
+			const ast = parser.parseExpression(code);
+			const callback = ast as t.Function;
+
+			const result = optimizer.canBatchArrayMethod(callback);
+
+			expect(result.canBatch).toBe(false);
+			expect(result.reason).toBe('Multiple pausable calls');
+		});
+
+		test('❌ Non-async callback - CANNOT BATCH', () => {
+			const code = `(item) => { console.log(item); }`;
+			const ast = parser.parseExpression(code);
+			const callback = ast as t.Function;
+
+			const result = optimizer.canBatchArrayMethod(callback);
+
+			expect(result.canBatch).toBe(false);
+			expect(result.reason).toBe('Not async');
+		});
+
+		test('❌ No pausable calls - CANNOT BATCH', () => {
+			const code = `async (item) => { await fetch(item); }`;
+			const ast = parser.parseExpression(code);
+			const callback = ast as t.Function;
+
+			const result = optimizer.canBatchArrayMethod(callback);
+
+			expect(result.canBatch).toBe(false);
+			expect(result.reason).toBe('No pausable calls');
+		});
+
+		test('❌ Multiple independent LLM calls - CANNOT BATCH (too complex)', () => {
+			const code = `async (item) => { 
+        await atp.llm.call({ prompt: 'A' + item });
+        await atp.llm.call({ prompt: 'B' + item });
+      }`;
+			const ast = parser.parseExpression(code);
+			const callback = ast as t.Function;
+
+			const result = optimizer.canBatchArrayMethod(callback);
+
+			expect(result.canBatch).toBe(false);
+			expect(result.reason).toBe('Multiple pausable calls');
+		});
+	});
+
+	describe('canBatchForOfLoop', () => {
+		test('✅ Simple for...of with single LLM call - CAN BATCH', () => {
+			const code = `for (const item of items) { await atp.llm.call({ prompt: item }); }`;
+			const ast = parser.parse(code, { sourceType: 'module' });
+			const loop = ast.program.body[0] as t.ForOfStatement;
+
+			const result = optimizer.canBatchForOfLoop(loop);
+
+			expect(result.canBatch).toBe(true);
+			expect(result.llmCallPattern).toBe('single');
+		});
+
+		test('❌ for...of with break - CANNOT BATCH', () => {
+			const code = `for (const item of items) { 
+        await atp.llm.call({ prompt: item });
+        if (item === 'stop') break;
+      }`;
+			const ast = parser.parse(code, { sourceType: 'module' });
+			const loop = ast.program.body[0] as t.ForOfStatement;
+
+			const result = optimizer.canBatchForOfLoop(loop);
+
+			expect(result.canBatch).toBe(false);
+			expect(result.reason).toBe('Contains break/continue');
+		});
+
+		test('❌ for...of with continue - CANNOT BATCH', () => {
+			const code = `for (const item of items) { 
+        if (!item.valid) continue;
+        await atp.llm.call({ prompt: item });
+      }`;
+			const ast = parser.parse(code, { sourceType: 'module' });
+			const loop = ast.program.body[0] as t.ForOfStatement;
+
+			const result = optimizer.canBatchForOfLoop(loop);
+
+			expect(result.canBatch).toBe(false);
+			expect(result.reason).toBe('Contains break/continue');
+		});
+
+		test('✅ for...of with conditional - CAN BATCH (smart decision later)', () => {
+			const code = `for (const item of items) { 
+        if (item.priority > 5) {
+          await atp.llm.call({ prompt: item });
+        }
+      }`;
+			const ast = parser.parse(code, { sourceType: 'module' });
+			const loop = ast.program.body[0] as t.ForOfStatement;
+
+			const result = optimizer.canBatchForOfLoop(loop);
+
+			expect(result.canBatch).toBe(true);
+			expect(result.hasConditionals).toBe(true);
+		});
+
+		test('❌ for...of with nested loop - CANNOT BATCH', () => {
+			const code = `for (const outer of items) { 
+        for (const inner of outer.items) {
+          await atp.llm.call({ prompt: inner });
+        }
+      }`;
+			const ast = parser.parse(code, { sourceType: 'module' });
+			const loop = ast.program.body[0] as t.ForOfStatement;
+
+			const result = optimizer.canBatchForOfLoop(loop);
+
+			expect(result.canBatch).toBe(false);
+			expect(result.reason).toBe('Contains nested loops');
+		});
+	});
+
+	describe('Performance Impact Examples', () => {
+		test('Example: 100 items with simple LLM call - WILL BE BATCHED', () => {
+			const code = `async (item) => await atp.llm.call({ prompt: item })`;
+			const ast = parser.parseExpression(code);
+			const callback = ast as t.Function;
+
+			const result = optimizer.canBatchArrayMethod(callback);
+
+			expect(result.canBatch).toBe(true);
+			// This means 100 items = 1 batch call (~2s) instead of 100 sequential (~200s)
+			// 100x speedup!
+		});
+
+		test('Example: forEach with complex logic - WILL BE SEQUENTIAL', () => {
+			const code = `async (item) => {
+        if (item.needsReview) {
+          const review = await atp.llm.call({ prompt: 'Review: ' + item });
+          if (review.approved) {
+            await atp.llm.call({ prompt: 'Finalize: ' + item });
+          }
+        }
+      }`;
+			const ast = parser.parseExpression(code);
+			const callback = ast as t.Function;
+
+			const result = optimizer.canBatchArrayMethod(callback);
+
+			expect(result.canBatch).toBe(false);
+			// Complex logic requires sequential execution with checkpoints
+		});
+	});
+});
+
+console.log('\n✅ Batch Optimizer tests complete!\n');

package/__tests__/unit/checkpoint-manager.test.ts

@@ -0,0 +1,145 @@
+import { CheckpointManager } from '../../src/runtime/checkpoint-manager';
+import type { CacheProvider } from '@mondaydotcomorg/atp-protocol';
+import type { LoopCheckpoint } from '../../src/types';
+
+describe('CheckpointManager', () => {
+	let mockCache: jest.Mocked<CacheProvider>;
+	let manager: CheckpointManager;
+
+	beforeEach(() => {
+		mockCache = {
+			get: jest.fn(),
+			set: jest.fn(),
+			delete: jest.fn(),
+		} as any;
+
+		manager = new CheckpointManager('exec-123', mockCache, 'test-checkpoint');
+	});
+
+	describe('save', () => {
+		it('should save checkpoint to cache', async () => {
+			const checkpoint: LoopCheckpoint = {
+				loopId: 'loop-1',
+				currentIndex: 5,
+				timestamp: Date.now(),
+			};
+
+			await manager.save(checkpoint);
+
+			expect(mockCache.set).toHaveBeenCalledWith(
+				'test-checkpoint:exec-123:loop-1',
+				checkpoint,
+				3600
+			);
+		});
+
+		it('should save checkpoint with results', async () => {
+			const checkpoint: LoopCheckpoint = {
+				loopId: 'loop-1',
+				currentIndex: 3,
+				results: ['a', 'b', 'c'],
+				timestamp: Date.now(),
+			};
+
+			await manager.save(checkpoint);
+
+			expect(mockCache.set).toHaveBeenCalledWith(
+				'test-checkpoint:exec-123:loop-1',
+				checkpoint,
+				3600
+			);
+		});
+
+		it('should throw CheckpointError if size exceeds limit', async () => {
+			const largeArray = Array(100000).fill('x'.repeat(1000));
+			const checkpoint: LoopCheckpoint = {
+				loopId: 'loop-1',
+				currentIndex: 1,
+				results: largeArray,
+				timestamp: Date.now(),
+			};
+
+			await expect(manager.save(checkpoint)).rejects.toThrow('Checkpoint size');
+		});
+
+		it('should throw CheckpointError on cache failure', async () => {
+			mockCache.set.mockRejectedValue(new Error('Cache error'));
+
+			const checkpoint: LoopCheckpoint = {
+				loopId: 'loop-1',
+				currentIndex: 1,
+				timestamp: Date.now(),
+			};
+
+			await expect(manager.save(checkpoint)).rejects.toThrow('Checkpoint save failed');
+		});
+	});
+
+	describe('load', () => {
+		it('should load checkpoint from cache', async () => {
+			const checkpoint: LoopCheckpoint = {
+				loopId: 'loop-1',
+				currentIndex: 5,
+				timestamp: Date.now(),
+			};
+
+			mockCache.get.mockResolvedValue(checkpoint);
+
+			const result = await manager.load('loop-1');
+
+			expect(result).toEqual(checkpoint);
+			expect(mockCache.get).toHaveBeenCalledWith('test-checkpoint:exec-123:loop-1');
+		});
+
+		it('should return null if checkpoint not found', async () => {
+			mockCache.get.mockResolvedValue(null);
+
+			const result = await manager.load('loop-1');
+
+			expect(result).toBeNull();
+		});
+
+		it('should convert completed array to Set', async () => {
+			const checkpoint = {
+				loopId: 'loop-1',
+				currentIndex: 5,
+				completed: [0, 1, 2],
+				timestamp: Date.now(),
+			};
+
+			mockCache.get.mockResolvedValue(checkpoint);
+
+			const result = await manager.load('loop-1');
+
+			expect(result).not.toBeNull();
+			expect(result!.completed).toBeInstanceOf(Set);
+			expect(result!.completed).toEqual(new Set([0, 1, 2]));
+		});
+
+		it('should throw CheckpointError on cache failure', async () => {
+			mockCache.get.mockRejectedValue(new Error('Cache error'));
+
+			await expect(manager.load('loop-1')).rejects.toThrow('Checkpoint load failed');
+		});
+	});
+
+	describe('clear', () => {
+		it('should clear checkpoint from cache', async () => {
+			await manager.clear('loop-1');
+
+			expect(mockCache.delete).toHaveBeenCalledWith('test-checkpoint:exec-123:loop-1');
+		});
+
+		it('should throw CheckpointError on cache failure', async () => {
+			mockCache.delete.mockRejectedValue(new Error('Cache error'));
+
+			await expect(manager.clear('loop-1')).rejects.toThrow('Checkpoint clear failed');
+		});
+	});
+
+	describe('getExecutionId', () => {
+		it('should return execution ID', () => {
+			expect(manager.getExecutionId()).toBe('exec-123');
+		});
+	});
+});