@mondaydotcomorg/atp-compiler 0.17.14

package/dist/runtime/src/progress/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../runtime/src/progress/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC"}

package/dist/runtime/src/progress/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/runtime/src/progress/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../runtime/src/progress/types.ts"],"names":[],"mappings":""}

package/dist/runtime/src/registry.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Runtime API Registry
+ *
+ */
+import type { RuntimeAPIMetadata } from './metadata/index.js';
+/**
+ * Get all registered runtime APIs metadata
+ *
+ * This is generated at BUILD TIME by ts-morph, not at runtime
+ */
+export declare function getAllAPIs(): RuntimeAPIMetadata[];
+/**
+ * Get metadata for a specific API by name
+ */
+export declare function getAPI(name: string): RuntimeAPIMetadata | undefined;
+//# sourceMappingURL=registry.d.ts.map

package/dist/runtime/src/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../runtime/src/registry.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAG9D;;;;GAIG;AACH,wBAAgB,UAAU,IAAI,kBAAkB,EAAE,CAEjD;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS,CAEnE"}

package/dist/runtime/src/registry.js

@@ -0,0 +1,16 @@
+import { GENERATED_METADATA } from './metadata/generated.js';
+/**
+ * Get all registered runtime APIs metadata
+ *
+ * This is generated at BUILD TIME by ts-morph, not at runtime
+ */
+export function getAllAPIs() {
+    return GENERATED_METADATA;
+}
+/**
+ * Get metadata for a specific API by name
+ */
+export function getAPI(name) {
+    return GENERATED_METADATA.find((api) => api.name === name);
+}
+//# sourceMappingURL=registry.js.map

package/dist/runtime/src/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../../../runtime/src/registry.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAE7D;;;;GAIG;AACH,MAAM,UAAU,UAAU;IACzB,OAAO,kBAAkB,CAAC;AAC3B,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,MAAM,CAAC,IAAY;IAClC,OAAO,kBAAkB,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;AAC5D,CAAC"}

package/dist/runtime/src/utils.d.ts

@@ -0,0 +1,11 @@
+export interface RetryOptions {
+    maxAttempts: number;
+    delayMs: number;
+}
+export declare const utils: {
+    sleep(ms: number): Promise<void>;
+    retry<T>(fn: () => Promise<T>, options: RetryOptions): Promise<T>;
+    parallel<T>(tasks: Array<() => Promise<T>>): Promise<T[]>;
+    sequence<T>(tasks: Array<() => Promise<T>>): Promise<T[]>;
+};
+//# sourceMappingURL=utils.d.ts.map

package/dist/runtime/src/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../runtime/src/utils.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,KAAK;cACD,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;UAI1B,CAAC,MAAM,MAAM,OAAO,CAAC,CAAC,CAAC,WAAW,YAAY,GAAG,OAAO,CAAC,CAAC,CAAC;aAexD,CAAC,SAAS,KAAK,CAAC,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;aAIhD,CAAC,SAAS,KAAK,CAAC,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;CAO/D,CAAC"}

package/dist/runtime/src/utils.js

@@ -0,0 +1,31 @@
+export const utils = {
+    async sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    },
+    async retry(fn, options) {
+        let lastError;
+        for (let attempt = 1; attempt <= options.maxAttempts; attempt++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt < options.maxAttempts) {
+                    await this.sleep(options.delayMs);
+                }
+            }
+        }
+        throw lastError;
+    },
+    async parallel(tasks) {
+        return Promise.all(tasks.map((task) => task()));
+    },
+    async sequence(tasks) {
+        const results = [];
+        for (const task of tasks) {
+            results.push(await task());
+        }
+        return results;
+    },
+};
+//# sourceMappingURL=utils.js.map

package/dist/runtime/src/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../runtime/src/utils.ts"],"names":[],"mappings":"AAKA,MAAM,CAAC,MAAM,KAAK,GAAG;IACpB,KAAK,CAAC,KAAK,CAAC,EAAU;QACrB,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;IAC1D,CAAC;IAED,KAAK,CAAC,KAAK,CAAI,EAAoB,EAAE,OAAqB;QACzD,IAAI,SAA4B,CAAC;QACjC,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,IAAI,OAAO,CAAC,WAAW,EAAE,OAAO,EAAE,EAAE,CAAC;YACjE,IAAI,CAAC;gBACJ,OAAO,MAAM,EAAE,EAAE,CAAC;YACnB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBAChB,SAAS,GAAG,KAAc,CAAC;gBAC3B,IAAI,OAAO,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;oBACnC,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;gBACnC,CAAC;YACF,CAAC;QACF,CAAC;QACD,MAAM,SAAS,CAAC;IACjB,CAAC;IAED,KAAK,CAAC,QAAQ,CAAI,KAA8B;QAC/C,OAAO,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IACjD,CAAC;IAED,KAAK,CAAC,QAAQ,CAAI,KAA8B;QAC/C,MAAM,OAAO,GAAQ,EAAE,CAAC;QACxB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YAC1B,OAAO,CAAC,IAAI,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC;QAC5B,CAAC;QACD,OAAO,OAAO,CAAC;IAChB,CAAC;CACD,CAAC"}

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/index.ts","../src/types.ts","../src/runtime/batch-parallel.ts","../src/runtime/checkpoint-manager.ts","../src/runtime/context.ts","../src/runtime/errors.ts","../src/runtime/index.ts","../src/runtime/resumable-arrays.ts","../src/runtime/resumable-loops.ts","../src/runtime/resumable-parallel.ts","../src/transformer/array-transformer-batch.ts","../src/transformer/array-transformer-sequential.ts","../src/transformer/array-transformer-utils.ts","../src/transformer/array-transformer-wrappers.ts","../src/transformer/array-transformer.ts","../src/transformer/batch-detector.ts","../src/transformer/batch-optimizer.ts","../src/transformer/detector.ts","../src/transformer/index.ts","../src/transformer/loop-transformer.ts","../src/transformer/promise-transformer.ts","../src/transformer/utils.ts"],"version":"5.9.3"}

package/jest.config.js

@@ -0,0 +1,29 @@
+export default {
+	preset: 'ts-jest',
+	testEnvironment: 'node',
+	roots: ['<rootDir>/__tests__'],
+	testMatch: ['**/*.test.ts'],
+	moduleNameMapper: {
+		'^(\\.{1,2}/.*)\\.js$': '$1',
+		'^@mondaydotcomorg/atp-runtime$': '<rootDir>/../runtime/src/index.ts',
+		'^@mondaydotcomorg/atp-protocol$': '<rootDir>/../protocol/src/index.ts',
+	},
+	extensionsToTreatAsEsm: ['.ts'],
+	transform: {
+		'^.+\\.tsx?$': [
+			'ts-jest',
+			{
+				useESM: true,
+			},
+		],
+	},
+	collectCoverageFrom: ['src/**/*.ts', '!src/**/*.d.ts', '!src/index.ts'],
+	coverageThreshold: {
+		global: {
+			branches: 95,
+			functions: 95,
+			lines: 95,
+			statements: 95,
+		},
+	},
+};

package/package.json

@@ -0,0 +1,56 @@
+{
+	"name": "@mondaydotcomorg/atp-compiler",
+	"version": "0.17.14",
+	"description": "Production-ready compiler for transforming async iteration patterns into resumable operations with checkpoint-based state management",
+	"type": "module",
+	"main": "dist/atp-compiler/src/index.js",
+	"types": "dist/atp-compiler/src/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/atp-compiler/src/index.d.ts",
+			"import": "./dist/atp-compiler/src/index.js"
+		},
+		"./*": {
+			"types": "./dist/atp-compiler/src/*.d.ts",
+			"import": "./dist/atp-compiler/src/*.js"
+		}
+	},
+	"scripts": {
+		"build": "tsc",
+		"test": "jest",
+		"test:watch": "jest --watch",
+		"test:coverage": "jest --coverage",
+		"test:mutation": "stryker run",
+		"lint": "tsc --noEmit",
+		"clean": "rm -rf dist"
+	},
+	"keywords": [
+		"agent-tool-protocol",
+		"compiler",
+		"resumable",
+		"async",
+		"checkpoint"
+	],
+	"author": "",
+	"license": "MIT",
+	"dependencies": {
+		"@babel/generator": "^7.26.0",
+		"@babel/parser": "^7.26.0",
+		"@babel/traverse": "^7.26.0",
+		"@babel/types": "^7.26.0",
+		"nanoid": "^5.0.0"
+	},
+	"peerDependencies": {
+		"@mondaydotcomorg/atp-protocol": "0.17.14",
+		"@mondaydotcomorg/atp-runtime": "0.17.14"
+	},
+	"devDependencies": {
+		"@stryker-mutator/core": "^8.0.0",
+		"@types/babel__generator": "^7.6.0",
+		"@types/babel__traverse": "^7.20.0",
+		"@types/jest": "^29.5.0",
+		"fast-check": "^3.15.0",
+		"jest": "^29.7.0",
+		"typescript": "^5.3.0"
+	}
+}

package/project.json

@@ -0,0 +1,31 @@
+{
+	"name": "@mondaydotcomorg/atp-compiler",
+	"$schema": "../../node_modules/nx/schemas/project-schema.json",
+	"sourceRoot": "packages/atp-compiler/src",
+	"projectType": "library",
+	"targets": {
+		"build": {
+			"executor": "nx:run-commands",
+			"outputs": ["{workspaceRoot}/packages/atp-compiler/dist"],
+			"options": {
+				"command": "tsc --build packages/atp-compiler/tsconfig.json",
+				"cwd": "{workspaceRoot}"
+			}
+		},
+		"clean": {
+			"executor": "nx:run-commands",
+			"options": {
+				"command": "rm -rf packages/atp-compiler/dist"
+			}
+		},
+		"lint": {
+			"executor": "nx:run-commands",
+			"options": {
+				"command": "cd packages/atp-compiler && npm run lint"
+			}
+		}
+	},
+	"tags": [
+		"atp-core"
+	]
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './transformer/index.js';
+export * from './runtime/index.js';
+
+export { ATPCompiler } from './transformer/index.js';
+export { initializeRuntime, cleanupRuntime } from './runtime/index.js';

package/src/runtime/batch-parallel.ts

@@ -0,0 +1,22 @@
+import { BatchPauseExecutionError } from './errors.js';
+import type { BatchCallInfo } from '../types.js';
+import {
+	nextSequenceNumber,
+	getCachedResult,
+	getCallSequenceNumber,
+} from '@mondaydotcomorg/atp-runtime';
+
+export async function batchParallel<T>(
+	batchCalls: BatchCallInfo[],
+	parallelId: string
+): Promise<T[]> {
+	const currentSequence = getCallSequenceNumber();
+	const cachedResult = getCachedResult(currentSequence);
+	if (cachedResult !== undefined) {
+		nextSequenceNumber();
+		return cachedResult as T[];
+	}
+
+	const sequenceForPause = nextSequenceNumber();
+	throw new BatchPauseExecutionError(batchCalls, parallelId, sequenceForPause);
+}

package/src/runtime/checkpoint-manager.ts

@@ -0,0 +1,105 @@
+import type { CacheProvider } from '@mondaydotcomorg/atp-protocol';
+import type { LoopCheckpoint } from '../types.js';
+import { CheckpointError, CheckpointOperation } from './errors.js';
+
+const MAX_CHECKPOINT_SIZE = 10 * 1024 * 1024;
+const CHECKPOINT_TTL = 3600;
+
+export class CheckpointManager {
+	private cache: CacheProvider;
+	private executionId: string;
+	private prefix: string;
+
+	constructor(executionId: string, cache: CacheProvider, prefix = 'checkpoint') {
+		this.executionId = executionId;
+		this.cache = cache;
+		this.prefix = prefix;
+	}
+
+	async save(checkpoint: LoopCheckpoint): Promise<void> {
+		const key = this.getKey(checkpoint.loopId);
+
+		try {
+			const serialized = JSON.stringify(checkpoint);
+
+			if (serialized.length > MAX_CHECKPOINT_SIZE) {
+				throw new CheckpointError(
+					`Checkpoint size ${serialized.length} exceeds maximum ${MAX_CHECKPOINT_SIZE}`,
+					checkpoint.loopId,
+					CheckpointOperation.SAVE
+				);
+			}
+
+			await this.cache.set(key, checkpoint, CHECKPOINT_TTL);
+		} catch (error) {
+			if (error instanceof CheckpointError) {
+				throw error;
+			}
+			const message = error instanceof Error ? error.message : String(error);
+			throw new CheckpointError(message, checkpoint.loopId, CheckpointOperation.SAVE);
+		}
+	}
+
+	async load(loopId: string): Promise<LoopCheckpoint | null> {
+		const key = this.getKey(loopId);
+
+		try {
+			const checkpoint = await this.cache.get<LoopCheckpoint>(key);
+
+			if (!checkpoint) {
+				return null;
+			}
+
+			if (checkpoint.completed && checkpoint.completed instanceof Array) {
+				checkpoint.completed = new Set(checkpoint.completed);
+			}
+
+			return checkpoint;
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			throw new CheckpointError(message, loopId, CheckpointOperation.LOAD);
+		}
+	}
+
+	async clear(loopId: string): Promise<void> {
+		const key = this.getKey(loopId);
+
+		try {
+			await this.cache.delete(key);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			throw new CheckpointError(message, loopId, CheckpointOperation.CLEAR);
+		}
+	}
+
+	async clearAll(): Promise<void> {}
+
+	private getKey(loopId: string): string {
+		return `${this.prefix}:${this.executionId}:${loopId}`;
+	}
+
+	getExecutionId(): string {
+		return this.executionId;
+	}
+}
+
+let globalCheckpointManager: CheckpointManager | null = null;
+
+export function setCheckpointManager(manager: CheckpointManager): void {
+	globalCheckpointManager = manager;
+}
+
+export function getCheckpointManager(): CheckpointManager {
+	if (!globalCheckpointManager) {
+		throw new Error('CheckpointManager not initialized');
+	}
+	return globalCheckpointManager;
+}
+
+export function clearCheckpointManager(): void {
+	globalCheckpointManager = null;
+}
+
+export function hasCheckpointManager(): boolean {
+	return globalCheckpointManager !== null;
+}

package/src/runtime/context.ts

@@ -0,0 +1,33 @@
+import type { RuntimeContext } from '../types.js';
+
+const contextStack: RuntimeContext[] = [];
+
+export function setRuntimeContext(context: RuntimeContext): void {
+	contextStack.push(context);
+}
+
+export function getRuntimeContext(): RuntimeContext {
+	const context = contextStack[contextStack.length - 1];
+	if (!context) {
+		throw new Error('No runtime context available. Compiler runtime not properly initialized.');
+	}
+	return context;
+}
+
+export function clearRuntimeContext(): void {
+	contextStack.pop();
+}
+
+export function hasRuntimeContext(): boolean {
+	return contextStack.length > 0;
+}
+
+let idCounter = 0;
+
+export function generateUniqueId(prefix: string): string {
+	return `${prefix}_${Date.now()}_${idCounter++}`;
+}
+
+export function resetIdCounter(): void {
+	idCounter = 0;
+}

package/src/runtime/errors.ts

@@ -0,0 +1,79 @@
+import type { BatchCallInfo } from '../types.js';
+
+export enum CheckpointOperation {
+	SAVE = 'save',
+	LOAD = 'load',
+	CLEAR = 'clear',
+}
+
+export class BatchPauseExecutionError extends Error {
+	public readonly calls: BatchCallInfo[];
+	public readonly batchId: string;
+	public readonly sequenceNumber: number;
+
+	constructor(calls: BatchCallInfo[], batchId: string, sequenceNumber: number) {
+		super(`Batch pause for parallel execution (${calls.length} callbacks)`);
+		this.name = 'BatchPauseExecutionError';
+		this.calls = calls;
+		this.batchId = batchId;
+		this.sequenceNumber = sequenceNumber;
+	}
+}
+
+export class CheckpointError extends Error {
+	public readonly checkpointId: string;
+	public readonly operation: CheckpointOperation;
+
+	constructor(message: string, checkpointId: string, operation: CheckpointOperation) {
+		super(`Checkpoint ${operation} failed for ${checkpointId}: ${message}`);
+		this.name = 'CheckpointError';
+		this.checkpointId = checkpointId;
+		this.operation = operation;
+	}
+}
+
+export class TransformationError extends Error {
+	public readonly code: string;
+	public readonly pattern: string;
+	public readonly location?: { line: number; column: number };
+
+	constructor(
+		message: string,
+		code: string,
+		pattern: string,
+		location?: { line: number; column: number }
+	) {
+		const loc = location ? ` at line ${location.line}:${location.column}` : '';
+		super(`Transformation failed for ${pattern}${loc}: ${message}`);
+		this.name = 'TransformationError';
+		this.code = code;
+		this.pattern = pattern;
+		this.location = location;
+	}
+}
+
+export class InfiniteLoopDetectionError extends Error {
+	public readonly loopId: string;
+	public readonly iterationCount: number;
+
+	constructor(loopId: string, iterationCount: number) {
+		super(
+			`Infinite loop detected: ${loopId} exceeded ${iterationCount} iterations without completing`
+		);
+		this.name = 'InfiniteLoopDetectionError';
+		this.loopId = loopId;
+		this.iterationCount = iterationCount;
+	}
+}
+
+export function isBatchPauseError(error: unknown): error is BatchPauseExecutionError {
+	return error instanceof BatchPauseExecutionError;
+}
+
+export function isCheckpointError(error: unknown): error is CheckpointError {
+	return error instanceof CheckpointError;
+}
+
+export function isTransformationError(error: unknown): error is TransformationError {
+	return error instanceof TransformationError;
+}

package/src/runtime/index.ts

@@ -0,0 +1,35 @@
+export * from './errors.js';
+export * from './context.js';
+export * from './checkpoint-manager.js';
+export * from './resumable-loops.js';
+export * from './resumable-arrays.js';
+export * from './resumable-parallel.js';
+export * from './batch-parallel.js';
+
+import type { CacheProvider } from '@mondaydotcomorg/atp-protocol';
+import { CheckpointManager, setCheckpointManager } from './checkpoint-manager.js';
+import { setRuntimeContext } from './context.js';
+
+export interface InitializeRuntimeOptions {
+	executionId: string;
+	cache: CacheProvider;
+	checkpointPrefix?: string;
+}
+
+export function initializeRuntime(options: InitializeRuntimeOptions): void {
+	const checkpointManager = new CheckpointManager(
+		options.executionId,
+		options.cache,
+		options.checkpointPrefix
+	);
+
+	setCheckpointManager(checkpointManager);
+
+	setRuntimeContext({
+		executionId: options.executionId,
+		cache: options.cache,
+		checkpointPrefix: options.checkpointPrefix,
+	});
+}
+
+export function cleanupRuntime(): void {}